Remove ScopedVector from chrome/browser/ui.

chrome/browser/ui/webui/options/preferences_browsertest.cc

 // Copyright (c) 2012 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/ui/webui/options/preferences_browsertest.h"
 
 #include <stddef.h>
 
 #include <iostream>
 #include <memory>
@@ skipping 197 matching lines @@
 void PreferencesBrowserTest::SetUpInProcessBrowserTestFixture() {
   // Sets up a mock policy provider for user and device policies.
   EXPECT_CALL(policy_provider_, IsInitializationComplete(_))
       .WillRepeatedly(Return(true));
   policy::BrowserPolicyConnector::SetPolicyProviderForTesting(
       &policy_provider_);
 }
 
 void PreferencesBrowserTest::SetUserPolicies(
     const std::vector<std::string>& names,
-    const std::vector<base::Value*>& values,
+    const std::vector<std::unique_ptr<base::Value>>& values,
     policy::PolicyLevel level) {
   policy::PolicyMap map;
   for (size_t i = 0; i < names.size(); ++i) {
     map.Set(names[i], level, policy::POLICY_SCOPE_USER,
             policy::POLICY_SOURCE_CLOUD, values[i]->CreateDeepCopy(), nullptr);
   }
   policy_provider_.UpdateChromePolicy(map);
 }
 
 void PreferencesBrowserTest::ClearUserPolicies() {
   policy::PolicyMap empty_policy_map;
   policy_provider_.UpdateChromePolicy(empty_policy_map);
 }
 
 void PreferencesBrowserTest::SetUserValues(
     const std::vector<std::string>& names,
-    const std::vector<base::Value*>& values) {
+    const std::vector<std::unique_ptr<base::Value>>& values) {
   for (size_t i = 0; i < names.size(); ++i) {
     pref_service()->Set(names[i].c_str(), *values[i]);
   }
 }
 
 void PreferencesBrowserTest::VerifyKeyValue(const base::DictionaryValue& dict,
                                             const std::string& key,
                                             const base::Value& expected) {
   const base::Value* actual = NULL;
   EXPECT_TRUE(dict.Get(key, &actual)) << "Was checking key: " << key;
   if (actual)
     EXPECT_EQ(expected, *actual) << "Was checking key: " << key;
 }
 
-void PreferencesBrowserTest::VerifyPref(const base::DictionaryValue* prefs,
-                                        const std::string& name,
-                                        const base::Value* value,
-                                        const std::string& controlledBy,
-                                        bool disabled,
-                                        bool uncommitted) {
+void PreferencesBrowserTest::VerifyPref(
+    const base::DictionaryValue* prefs,
+    const std::string& name,
+    const std::unique_ptr<base::Value>& value,
+    const std::string& controlledBy,
+    bool disabled,
+    bool uncommitted) {
   const base::Value* pref = NULL;
   const base::DictionaryValue* dict = NULL;
   ASSERT_TRUE(prefs->GetWithoutPathExpansion(name, &pref));
   ASSERT_TRUE(pref->GetAsDictionary(&dict));
   VerifyKeyValue(*dict, "value", *value);
   if (!controlledBy.empty())
     VerifyKeyValue(*dict, "controlledBy", base::StringValue(controlledBy));
   else
     EXPECT_FALSE(dict->HasKey("controlledBy"));
 
   if (disabled)
     VerifyKeyValue(*dict, "disabled", base::FundamentalValue(true));
   else if (dict->HasKey("disabled"))
     VerifyKeyValue(*dict, "disabled", base::FundamentalValue(false));
 
   if (uncommitted)
     VerifyKeyValue(*dict, "uncommitted", base::FundamentalValue(true));
   else if (dict->HasKey("uncommitted"))
     VerifyKeyValue(*dict, "uncommitted", base::FundamentalValue(false));
 }
 
-void PreferencesBrowserTest::VerifyObservedPref(const std::string& json,
-                                                const std::string& name,
-                                                const base::Value* value,
-                                                const std::string& controlledBy,
-                                                bool disabled,
-                                                bool uncommitted) {
+void PreferencesBrowserTest::VerifyObservedPref(
+    const std::string& json,
+    const std::string& name,
+    const std::unique_ptr<base::Value>& value,
+    const std::string& controlledBy,
+    bool disabled,
+    bool uncommitted) {
   std::unique_ptr<base::Value> observed_value_ptr =
       base::JSONReader::Read(json);
   const base::DictionaryValue* observed_dict;
   ASSERT_TRUE(observed_value_ptr.get());
   ASSERT_TRUE(observed_value_ptr->GetAsDictionary(&observed_dict));
   VerifyPref(observed_dict, name, value, controlledBy, disabled, uncommitted);
 }
 
 void PreferencesBrowserTest::VerifyObservedPrefs(
     const std::string& json,
     const std::vector<std::string>& names,
-    const std::vector<base::Value*>& values,
+    const std::vector<std::unique_ptr<base::Value>>& values,
     const std::string& controlledBy,
     bool disabled,
     bool uncommitted) {
   std::unique_ptr<base::Value> observed_value_ptr =
       base::JSONReader::Read(json);
   const base::DictionaryValue* observed_dict;
   ASSERT_TRUE(observed_value_ptr.get());
   ASSERT_TRUE(observed_value_ptr->GetAsDictionary(&observed_dict));
   for (size_t i = 0; i < names.size(); ++i) {
     VerifyPref(observed_dict, names[i], values[i], controlledBy, disabled,
                uncommitted);
   }
 }
 
 void PreferencesBrowserTest::ExpectNoCommit(const std::string& name) {
   pref_change_registrar_->Add(
       name.c_str(),
       base::Bind(&PreferencesBrowserTest::OnPreferenceChanged,
                  base::Unretained(this)));
   EXPECT_CALL(*this, OnCommit(Property(&PrefService::Preference::name, name)))
       .Times(0);
 }
 
-void PreferencesBrowserTest::ExpectSetCommit(const std::string& name,
-                                             const base::Value* value) {
+void PreferencesBrowserTest::ExpectSetCommit(
+    const std::string& name,
+    const std::unique_ptr<base::Value>& value) {
   pref_change_registrar_->Add(
       name.c_str(),
       base::Bind(&PreferencesBrowserTest::OnPreferenceChanged,
                  base::Unretained(this)));
-  EXPECT_CALL(*this, OnCommit(AllOf(
-      Property(&PrefService::Preference::name, name),
-      Property(&PrefService::Preference::IsUserControlled, true),
-      Property(&PrefService::Preference::GetValue, EqualsValue(value)))));
+  EXPECT_CALL(
+      *this,
+      OnCommit(AllOf(Property(&PrefService::Preference::name, name),
+                     Property(&PrefService::Preference::IsUserControlled, true),
+                     Property(&PrefService::Preference::GetValue,
+                              EqualsValue(value.get())))));
 }
 
 void PreferencesBrowserTest::ExpectClearCommit(const std::string& name) {
   pref_change_registrar_->Add(
       name.c_str(),
       base::Bind(&PreferencesBrowserTest::OnPreferenceChanged,
                  base::Unretained(this)));
   EXPECT_CALL(*this, OnCommit(AllOf(
       Property(&PrefService::Preference::name, name),
       Property(&PrefService::Preference::IsUserControlled, false))));
 }
 
 void PreferencesBrowserTest::VerifyAndClearExpectations() {
   Mock::VerifyAndClearExpectations(this);
   pref_change_registrar_->RemoveAll();
 }
 
 void PreferencesBrowserTest::SetupJavaScriptTestEnvironment(
     const std::vector<std::string>& pref_names,
     std::string* observed_json) const {
   std::stringstream javascript;
   javascript << "var testEnv = new TestEnv();";
-  for (std::vector<std::string>::const_iterator name = pref_names.begin();
-       name != pref_names.end(); ++name) {
+  for (auto name = pref_names.begin(); name != pref_names.end(); ++name) {
     javascript << "testEnv.addPref('" << name->c_str() << "');";
   }
   javascript << "testEnv.setupAndReply();";
   std::string temp_observed_json;
   if (!observed_json)
     observed_json = &temp_observed_json;
   ASSERT_TRUE(content::ExecuteScriptAndExtractString(
       render_view_host_, javascript.str(), observed_json));
 }
 
 void PreferencesBrowserTest::SetPref(const std::string& name,
                                      const std::string& type,
-                                     const base::Value* value,
+                                     const std::unique_ptr<base::Value>& value,
                                      bool commit,
                                      std::string* observed_json) {
   std::unique_ptr<base::Value> commit_ptr(new base::FundamentalValue(commit));
   std::stringstream javascript;
   javascript << "testEnv.runAndReply(function() {"
              << "  Preferences.set" << type << "Pref("
              << "      '" << name << "',"
              << "      " << *value << ","
              << "      " << *commit_ptr << ");"
              << "});";
   ASSERT_TRUE(content::ExecuteScriptAndExtractString(
       render_view_host_, javascript.str(), observed_json));
 }
 
-void PreferencesBrowserTest::VerifySetPref(const std::string& name,
-                                           const std::string& type,
-                                           const base::Value* value,
-                                           bool commit) {
+void PreferencesBrowserTest::VerifySetPref(
+    const std::string& name,
+    const std::string& type,
+    const std::unique_ptr<base::Value>& value,
+    bool commit) {
   if (commit)
     ExpectSetCommit(name, value);
   else
     ExpectNoCommit(name);
   std::string observed_json;
   SetPref(name, type, value, commit, &observed_json);
   VerifyObservedPref(observed_json, name, value, std::string(), false, !commit);
   VerifyAndClearExpectations();
 }
 
-void PreferencesBrowserTest::VerifyClearPref(const std::string& name,
-                                             const base::Value* value,
-                                             bool commit) {
+void PreferencesBrowserTest::VerifyClearPref(
+    const std::string& name,
+    const std::unique_ptr<base::Value>& value,
+    bool commit) {
   if (commit)
     ExpectClearCommit(name);
   else
     ExpectNoCommit(name);
   std::string commit_json;
   base::JSONWriter::Write(base::FundamentalValue(commit), &commit_json);
   std::stringstream javascript;
   javascript << "testEnv.runAndReply(function() {"
              << "    Preferences.clearPref("
              << "      '" << name.c_str() << "',"
              << "      " << commit_json.c_str() << ");});";
   std::string observed_json;
   ASSERT_TRUE(content::ExecuteScriptAndExtractString(
       render_view_host_, javascript.str(), &observed_json));
   VerifyObservedPref(observed_json, name, value, "recommended", false, !commit);
   VerifyAndClearExpectations();
 }
 
-void PreferencesBrowserTest::VerifyCommit(const std::string& name,
-                                          const base::Value* value,
-                                          const std::string& controlledBy) {
+void PreferencesBrowserTest::VerifyCommit(
+    const std::string& name,
+    const std::unique_ptr<base::Value>& value,
+    const std::string& controlledBy) {
   std::stringstream javascript;
   javascript << "testEnv.runAndReply(function() {"
              << "    Preferences.getInstance().commitPref("
              << "        '" << name.c_str() << "');});";
   std::string observed_json;
   ASSERT_TRUE(content::ExecuteScriptAndExtractString(
       render_view_host_, javascript.str(), &observed_json));
   VerifyObservedPref(observed_json, name, value, controlledBy, false, false);
 }
 
-void PreferencesBrowserTest::VerifySetCommit(const std::string& name,
-                                             const base::Value* value) {
+void PreferencesBrowserTest::VerifySetCommit(
+    const std::string& name,
+    const std::unique_ptr<base::Value>& value) {
   ExpectSetCommit(name, value);
   VerifyCommit(name, value, std::string());
   VerifyAndClearExpectations();
 }
 
-void PreferencesBrowserTest::VerifyClearCommit(const std::string& name,
-                                               const base::Value* value) {
+void PreferencesBrowserTest::VerifyClearCommit(
+    const std::string& name,
+    const std::unique_ptr<base::Value>& value) {
   ExpectClearCommit(name);
   VerifyCommit(name, value, "recommended");
   VerifyAndClearExpectations();
 }
 
-void PreferencesBrowserTest::VerifyRollback(const std::string& name,
-                                            const base::Value* value,
-                                            const std::string& controlledBy) {
+void PreferencesBrowserTest::VerifyRollback(
+    const std::string& name,
+    const std::unique_ptr<base::Value>& value,
+    const std::string& controlledBy) {
   ExpectNoCommit(name);
   std::stringstream javascript;
   javascript << "testEnv.runAndReply(function() {"
              << "    Preferences.getInstance().rollbackPref("
              << "        '" << name.c_str() << "');});";
   std::string observed_json;
   ASSERT_TRUE(content::ExecuteScriptAndExtractString(
       render_view_host_, javascript.str(), &observed_json));
   VerifyObservedPref(observed_json, name, value, controlledBy, false, true);
   VerifyAndClearExpectations();
 }
 
 void PreferencesBrowserTest::StartObserving() {
   ASSERT_TRUE(content::ExecuteScript(
       render_view_host_, "testEnv.startObserving();"));
 }
 
 void PreferencesBrowserTest::FinishObserving(std::string* observed_json) {
   ASSERT_TRUE(content::ExecuteScriptAndExtractString(
       render_view_host_,
       "testEnv.finishObservingAndReply();",
       observed_json));
 }
 
 void PreferencesBrowserTest::UseDefaultTestPrefs(bool includeListPref) {
   // Boolean pref.
   types_.push_back("Boolean");
   pref_names_.push_back(prefs::kAlternateErrorPagesEnabled);
   policy_names_.push_back(policy::key::kAlternateErrorPagesEnabled);
-  non_default_values_.push_back(new base::FundamentalValue(false));
+  non_default_values_.push_back(
+      base::MakeUnique<base::FundamentalValue>(false));
 
   // Integer pref.
   types_.push_back("Integer");
   pref_names_.push_back(prefs::kRestoreOnStartup);
   policy_names_.push_back(policy::key::kRestoreOnStartup);
-  non_default_values_.push_back(new base::FundamentalValue(4));
+  non_default_values_.push_back(base::MakeUnique<base::FundamentalValue>(4));
 
   // List pref.
   if (includeListPref) {
     types_.push_back("List");
     pref_names_.push_back(prefs::kURLsToRestoreOnStartup);
     policy_names_.push_back(policy::key::kRestoreOnStartupURLs);
-    base::ListValue* list = new base::ListValue;
+    std::unique_ptr<base::ListValue> list = base::MakeUnique<base::ListValue>();
     list->AppendString("http://www.example.com");
     list->AppendString("http://example.com");
-    non_default_values_.push_back(list);
+    non_default_values_.push_back(std::move(list));
   }
 
   // Retrieve default values.
-  for (std::vector<std::string>::const_iterator name = pref_names_.begin();
-        name != pref_names_.end(); ++name) {
+  for (auto name = pref_names_.begin(); name != pref_names_.end(); ++name) {
     default_values_.push_back(
-        pref_service()->GetDefaultPrefValue(name->c_str())->DeepCopy());
+        pref_service()->GetDefaultPrefValue(name->c_str())->CreateDeepCopy());

[Nico, 2017/01/03 18:12:35]

The reasoning being "eh it's just a test" I assume?

[Avi (use Gerrit), 2017/01/03 22:54:53]

I don't know what the ownership story of GetDefaultPrefValue is. The old code
makes a copy, so I'm assuming a copy is needed.

   }
 }
 
 // Verifies that initializing the JavaScript Preferences class fires the correct
 // notifications in JavaScript.
 IN_PROC_BROWSER_TEST_F(PreferencesBrowserTest, FetchPrefs) {
   UseDefaultTestPrefs(true);
   std::string observed_json;
 
   // Verify notifications when default values are in effect.
   SetupJavaScriptTestEnvironment(pref_names_, &observed_json);
-  VerifyObservedPrefs(
-      observed_json, pref_names_, default_values_.get(),
-      std::string(), false, false);
+  VerifyObservedPrefs(observed_json, pref_names_, default_values_,
+                      std::string(), false, false);
 
   // Verify notifications when recommended values are in effect.
-  SetUserPolicies(policy_names_, non_default_values_.get(),
+  SetUserPolicies(policy_names_, non_default_values_,
                   policy::POLICY_LEVEL_RECOMMENDED);
   SetupJavaScriptTestEnvironment(pref_names_, &observed_json);
-  VerifyObservedPrefs(observed_json, pref_names_, non_default_values_.get(),
+  VerifyObservedPrefs(observed_json, pref_names_, non_default_values_,
                       "recommended", false, false);
 
   // Verify notifications when mandatory values are in effect.
-  SetUserPolicies(policy_names_, non_default_values_.get(),
+  SetUserPolicies(policy_names_, non_default_values_,
                   policy::POLICY_LEVEL_MANDATORY);
   SetupJavaScriptTestEnvironment(pref_names_, &observed_json);
-  VerifyObservedPrefs(observed_json, pref_names_, non_default_values_.get(),
-                      "policy", true, false);
+  VerifyObservedPrefs(observed_json, pref_names_, non_default_values_, "policy",
+                      true, false);
 
   // Verify notifications when user-modified values are in effect.
   ClearUserPolicies();
-  SetUserValues(pref_names_, non_default_values_.get());
+  SetUserValues(pref_names_, non_default_values_);
   SetupJavaScriptTestEnvironment(pref_names_, &observed_json);
-  VerifyObservedPrefs(observed_json,
-                      pref_names_,
-                      non_default_values_.get(),
-                      std::string(),
-                      false,
-                      false);
+  VerifyObservedPrefs(observed_json, pref_names_, non_default_values_,
+                      std::string(), false, false);
 }
 
 // Verifies that setting a user-modified pref value through the JavaScript
 // Preferences class fires the correct notification in JavaScript and causes the
 // change to be committed to the C++ backend.
 IN_PROC_BROWSER_TEST_F(PreferencesBrowserTest, SetPrefs) {
   UseDefaultTestPrefs(false);
 
   ASSERT_NO_FATAL_FAILURE(SetupJavaScriptTestEnvironment(pref_names_, NULL));
   for (size_t i = 0; i < pref_names_.size(); ++i) {
     VerifySetPref(pref_names_[i], types_[i], non_default_values_[i], true);
   }
 }
 
 // Verifies that clearing a user-modified pref value through the JavaScript
 // Preferences class fires the correct notification in JavaScript and causes the
 // change to be committed to the C++ backend.
 IN_PROC_BROWSER_TEST_F(PreferencesBrowserTest, ClearPrefs) {
   UseDefaultTestPrefs(false);
 
-  SetUserPolicies(policy_names_, default_values_.get(),
+  SetUserPolicies(policy_names_, default_values_,
                   policy::POLICY_LEVEL_RECOMMENDED);
-  SetUserValues(pref_names_, non_default_values_.get());
+  SetUserValues(pref_names_, non_default_values_);
   ASSERT_NO_FATAL_FAILURE(SetupJavaScriptTestEnvironment(pref_names_, NULL));
   for (size_t i = 0; i < pref_names_.size(); ++i) {
     VerifyClearPref(pref_names_[i], default_values_[i], true);
   }
 }
 
 // Verifies that when the user-modified value of a dialog pref is set and the
 // change then committed through the JavaScript Preferences class, the correct
 // notifications fire and a commit to the C++ backend occurs in the latter step
 // only.
@@ skipping 14 matching lines @@
   UseDefaultTestPrefs(false);
 
   // Verify behavior when default values are in effect.
   ASSERT_NO_FATAL_FAILURE(SetupJavaScriptTestEnvironment(pref_names_, NULL));
   for (size_t i = 0; i < pref_names_.size(); ++i) {
     VerifySetPref(pref_names_[i], types_[i], non_default_values_[i], false);
     VerifyRollback(pref_names_[i], default_values_[i], std::string());
   }
 
   // Verify behavior when recommended values are in effect.
-  SetUserPolicies(policy_names_, default_values_.get(),
+  SetUserPolicies(policy_names_, default_values_,
                   policy::POLICY_LEVEL_RECOMMENDED);
   ASSERT_NO_FATAL_FAILURE(SetupJavaScriptTestEnvironment(pref_names_, NULL));
   for (size_t i = 0; i < pref_names_.size(); ++i) {
     VerifySetPref(pref_names_[i], types_[i], non_default_values_[i], false);
     VerifyRollback(pref_names_[i], default_values_[i], "recommended");
   }
 }
 
 // Verifies that when the user-modified value of a dialog pref is cleared and
 // the change then committed through the JavaScript Preferences class, the
 // correct notifications fire and a commit to the C++ backend occurs in the
 // latter step only.
 IN_PROC_BROWSER_TEST_F(PreferencesBrowserTest, DialogPrefsClearCommit) {
   UseDefaultTestPrefs(false);
 
-  SetUserPolicies(policy_names_, default_values_.get(),
+  SetUserPolicies(policy_names_, default_values_,
                   policy::POLICY_LEVEL_RECOMMENDED);
-  SetUserValues(pref_names_, non_default_values_.get());
+  SetUserValues(pref_names_, non_default_values_);
   ASSERT_NO_FATAL_FAILURE(SetupJavaScriptTestEnvironment(pref_names_, NULL));
   for (size_t i = 0; i < pref_names_.size(); ++i) {
     VerifyClearPref(pref_names_[i], default_values_[i], false);
     VerifyClearCommit(pref_names_[i], default_values_[i]);
   }
 }
 
 // Verifies that when the user-modified value of a dialog pref is cleared and
 // the change then rolled back through the JavaScript Preferences class, the
 // correct notifications fire and no commit to the C++ backend occurs.
 IN_PROC_BROWSER_TEST_F(PreferencesBrowserTest, DialogPrefsClearRollback) {
   UseDefaultTestPrefs(false);
 
-  SetUserPolicies(policy_names_, default_values_.get(),
+  SetUserPolicies(policy_names_, default_values_,
                   policy::POLICY_LEVEL_RECOMMENDED);
-  SetUserValues(pref_names_, non_default_values_.get());
+  SetUserValues(pref_names_, non_default_values_);
   ASSERT_NO_FATAL_FAILURE(SetupJavaScriptTestEnvironment(pref_names_, NULL));
   for (size_t i = 0; i < pref_names_.size(); ++i) {
     VerifyClearPref(pref_names_[i], default_values_[i], false);
     VerifyRollback(pref_names_[i], non_default_values_[i], std::string());
   }
 }
 
 // Verifies that when preference values change in the C++ backend, the correct
 // notifications fire in JavaScript.
 IN_PROC_BROWSER_TEST_F(PreferencesBrowserTest, NotificationsOnBackendChanges) {
   UseDefaultTestPrefs(false);
   std::string observed_json;
 
   ASSERT_NO_FATAL_FAILURE(SetupJavaScriptTestEnvironment(pref_names_, NULL));
 
   // Verify notifications when recommended values come into effect.
   StartObserving();
-  SetUserPolicies(policy_names_, non_default_values_.get(),
+  SetUserPolicies(policy_names_, non_default_values_,
                   policy::POLICY_LEVEL_RECOMMENDED);
   FinishObserving(&observed_json);
-  VerifyObservedPrefs(observed_json, pref_names_, non_default_values_.get(),
+  VerifyObservedPrefs(observed_json, pref_names_, non_default_values_,
                       "recommended", false, false);
 
   // Verify notifications when mandatory values come into effect.
   StartObserving();
-  SetUserPolicies(policy_names_, non_default_values_.get(),
+  SetUserPolicies(policy_names_, non_default_values_,
                   policy::POLICY_LEVEL_MANDATORY);
   FinishObserving(&observed_json);
-  VerifyObservedPrefs(observed_json, pref_names_, non_default_values_.get(),
-                      "policy", true, false);
+  VerifyObservedPrefs(observed_json, pref_names_, non_default_values_, "policy",
+                      true, false);
 
   // Verify notifications when default values come into effect.
   StartObserving();
   ClearUserPolicies();
   FinishObserving(&observed_json);
-  VerifyObservedPrefs(
-      observed_json, pref_names_, default_values_.get(),
-      std::string(), false, false);
+  VerifyObservedPrefs(observed_json, pref_names_, default_values_,
+                      std::string(), false, false);
 
   // Verify notifications when user-modified values come into effect.
   StartObserving();
-  SetUserValues(pref_names_, non_default_values_.get());
+  SetUserValues(pref_names_, non_default_values_);
   FinishObserving(&observed_json);
-  VerifyObservedPrefs(observed_json,
-                      pref_names_,
-                      non_default_values_.get(),
-                      std::string(),
-                      false,
-                      false);
+  VerifyObservedPrefs(observed_json, pref_names_, non_default_values_,
+                      std::string(), false, false);
 }
 
 #if defined(OS_CHROMEOS)
 
 // Verifies that initializing the JavaScript Preferences class fires the correct
 // notifications in JavaScript for pref values handled by the
 // CoreChromeOSOptionsHandler class.
 IN_PROC_BROWSER_TEST_F(PreferencesBrowserTest, ChromeOSDeviceFetchPrefs) {
   std::string observed_json;
 
   // Boolean pref.
   pref_names_.push_back(chromeos::kAccountsPrefAllowGuest);
-  default_values_.push_back(new base::FundamentalValue(true));
+  default_values_.push_back(base::MakeUnique<base::FundamentalValue>(true));
 
   // String pref.
   pref_names_.push_back(chromeos::kReleaseChannel);
-  default_values_.push_back(new base::StringValue(""));
+  default_values_.push_back(base::MakeUnique<base::StringValue>(""));
 
   // List pref.
   pref_names_.push_back(chromeos::kAccountsPrefUsers);
-  default_values_.push_back(new base::ListValue);
+  default_values_.push_back(base::MakeUnique<base::ListValue>());
 
   // Verify notifications when default values are in effect.
   SetupJavaScriptTestEnvironment(pref_names_, &observed_json);
-  VerifyObservedPrefs(observed_json, pref_names_, default_values_.get(),
-                      "owner", true, false);
+  VerifyObservedPrefs(observed_json, pref_names_, default_values_, "owner",
+                      true, false);
 }
 
 // Verifies that initializing the JavaScript Preferences class fires the correct
 // notifications in JavaScript for non-privileged pref values handled by the
 // CoreChromeOSOptionsHandler class.
 IN_PROC_BROWSER_TEST_F(PreferencesBrowserTest,
                        ChromeOSDeviceFetchNonPrivilegedPrefs) {
-  ScopedVector<base::Value> decorated_non_default_values;
+  std::vector<std::unique_ptr<base::Value>> decorated_non_default_values;
   std::string observed_json;
 
   // Non-privileged string pref.
   pref_names_.push_back(chromeos::kSystemTimezone);
-  default_values_.push_back(new base::StringValue("America/Los_Angeles"));
-  non_default_values_.push_back(new base::StringValue("America/New_York"));
+  default_values_.push_back(
+      base::MakeUnique<base::StringValue>("America/Los_Angeles"));
+  non_default_values_.push_back(
+      base::MakeUnique<base::StringValue>("America/New_York"));
   decorated_non_default_values.push_back(
-      non_default_values_.back()->DeepCopy());
+      non_default_values_.back()->CreateDeepCopy());
 
   // Verify notifications when default values are in effect.
   SetupJavaScriptTestEnvironment(pref_names_, &observed_json);
-  VerifyObservedPrefs(observed_json, pref_names_, default_values_.get(),
+  VerifyObservedPrefs(observed_json, pref_names_, default_values_,
                       std::string(), false, false);
 
   chromeos::CrosSettings* cros_settings = chromeos::CrosSettings::Get();
   cros_settings->Set(pref_names_[0], *non_default_values_[0]);
 
   // Verify notifications when non-default values are in effect.
   SetupJavaScriptTestEnvironment(pref_names_, &observed_json);
-  VerifyObservedPrefs(observed_json, pref_names_,
-                      decorated_non_default_values.get(),
+  VerifyObservedPrefs(observed_json, pref_names_, decorated_non_default_values,
                       std::string(), false, false);
 }
 
 class ManagedPreferencesBrowserTest : public PreferencesBrowserTest {
  protected:
   // PreferencesBrowserTest implementation:
   void SetUpInProcessBrowserTestFixture() override {
     // Set up fake install attributes.
     std::unique_ptr<chromeos::StubInstallAttributes> attributes =
         base::MakeUnique<chromeos::StubInstallAttributes>();
     attributes->SetEnterprise("example.com", "fake-id");
     policy::BrowserPolicyConnectorChromeOS::SetInstallAttributesForTesting(
         attributes.release());
 
     PreferencesBrowserTest::SetUpInProcessBrowserTestFixture();
   }
 };
 
 // Verifies that initializing the JavaScript Preferences class fires the correct
 // notifications in JavaScript for pref values handled by the
 // CoreChromeOSOptionsHandler class for a managed device.
 IN_PROC_BROWSER_TEST_F(ManagedPreferencesBrowserTest,
                        ChromeOSDeviceFetchPrefs) {
-  ScopedVector<base::Value> decorated_non_default_values;
+  std::vector<std::unique_ptr<base::Value>> decorated_non_default_values;
   std::string observed_json;
 
   // Boolean pref.
   pref_names_.push_back(chromeos::kAccountsPrefAllowGuest);
-  non_default_values_.push_back(new base::FundamentalValue(false));
+  non_default_values_.push_back(
+      base::MakeUnique<base::FundamentalValue>(false));
   decorated_non_default_values.push_back(
-      non_default_values_.back()->DeepCopy());
+      non_default_values_.back()->CreateDeepCopy());
 
   // String pref.
   pref_names_.push_back(chromeos::kReleaseChannel);
-  non_default_values_.push_back(new base::StringValue("stable-channel"));
+  non_default_values_.push_back(
+      base::MakeUnique<base::StringValue>("stable-channel"));
   decorated_non_default_values.push_back(
-      non_default_values_.back()->DeepCopy());
+      non_default_values_.back()->CreateDeepCopy());
 
   // List pref.
   pref_names_.push_back(chromeos::kAccountsPrefUsers);
-  base::ListValue* list = new base::ListValue;
+  std::unique_ptr<base::ListValue> list = base::MakeUnique<base::ListValue>();
   list->AppendString("me@google.com");
   list->AppendString("you@google.com");
-  non_default_values_.push_back(list);
-  list = new base::ListValue;
+  non_default_values_.push_back(std::move(list));
+  list = base::MakeUnique<base::ListValue>();
   auto dict = base::MakeUnique<base::DictionaryValue>();
   dict->SetString("username", "me@google.com");
   dict->SetString("name", "me@google.com");
   dict->SetString("email", "");
   dict->SetBoolean("owner", false);
   list->Append(std::move(dict));
   dict = base::MakeUnique<base::DictionaryValue>();
   dict->SetString("username", "you@google.com");
   dict->SetString("name", "you@google.com");
   dict->SetString("email", "");
   dict->SetBoolean("owner", false);
   list->Append(std::move(dict));
-  decorated_non_default_values.push_back(list);
+  decorated_non_default_values.push_back(std::move(list));
 
   chromeos::CrosSettings* cros_settings = chromeos::CrosSettings::Get();
   for (size_t i = 0; i < pref_names_.size(); ++i) {
     cros_settings->Set(pref_names_[i], *non_default_values_[i]);
   }
 
   // Verify notifications when mandatory values are in effect.
   SetupJavaScriptTestEnvironment(pref_names_, &observed_json);
-  VerifyObservedPrefs(observed_json, pref_names_,
-                      decorated_non_default_values.get(),
+  VerifyObservedPrefs(observed_json, pref_names_, decorated_non_default_values,
                       "policy", true, false);
 }
 
 // Verifies that initializing the JavaScript Preferences class fires the correct
 // notifications in JavaScript for non-privileged pref values handled by the
 // CoreChromeOSOptionsHandler class for a managed device.
 IN_PROC_BROWSER_TEST_F(ManagedPreferencesBrowserTest,
                        ChromeOSDeviceFetchNonPrivilegedPrefs) {
-  ScopedVector<base::Value> decorated_non_default_values;
+  std::vector<std::unique_ptr<base::Value>> decorated_non_default_values;
   std::string observed_json;
 
   // Non-privileged string pref.
   pref_names_.push_back(chromeos::kSystemTimezone);
-  non_default_values_.push_back(new base::StringValue("America/New_York"));
+  non_default_values_.push_back(
+      base::MakeUnique<base::StringValue>("America/New_York"));
   decorated_non_default_values.push_back(
-      non_default_values_.back()->DeepCopy());
+      non_default_values_.back()->CreateDeepCopy());
 
   // Verify notifications when mandatory values are in effect.
   chromeos::CrosSettings* cros_settings = chromeos::CrosSettings::Get();
   cros_settings->Set(pref_names_[0], *non_default_values_[0]);
 
   SetupJavaScriptTestEnvironment(pref_names_, &observed_json);
-  VerifyObservedPrefs(observed_json, pref_names_,
-                      decorated_non_default_values.get(),
+  VerifyObservedPrefs(observed_json, pref_names_, decorated_non_default_values,
                       std::string(), false, false);
 }
 
 namespace {
 
 const char* kUserProfilePath = "user_profile";
 
 }  // namespace
 
 class ProxyPreferencesBrowserTest : public PreferencesBrowserTest {
@@ skipping 85 matching lines @@
         type = "Integer";
         break;
       case base::Value::Type::STRING:
         type = "String";
         break;
       default:
         ASSERT_TRUE(false);
     }
 
     std::string observed_json;
-    SetPref(name, type, &value, true, &observed_json);
+    SetPref(name, type, value.CreateDeepCopy(), true, &observed_json);
   }
 
   void VerifyCurrentProxyServer(const std::string& expected_server,
                                 onc::ONCSource expected_source) {
     const chromeos::NetworkState* network = GetDefaultNetwork();
     ASSERT_TRUE(network);
     onc::ONCSource actual_source;
     std::unique_ptr<ProxyConfigDictionary> proxy_dict =
         chromeos::proxy_config::GetProxyConfigForNetwork(
             g_browser_process->local_state(), pref_service(), *network,
             &actual_source);
     ASSERT_TRUE(proxy_dict);
     std::string actual_proxy_server;
     EXPECT_TRUE(proxy_dict->GetProxyServer(&actual_proxy_server));
     EXPECT_EQ(expected_server, actual_proxy_server);
     EXPECT_EQ(expected_source, actual_source);
   }
 };
 
 // Verifies that proxy settings are correctly pushed to JavaScript during
 // initialization of the proxy settings page.
 IN_PROC_BROWSER_TEST_F(ProxyPreferencesBrowserTest, ChromeOSInitializeProxy) {
   // Boolean pref.
   pref_names_.push_back(chromeos::proxy_cros_settings_parser::kProxySingle);
-  non_default_values_.push_back(new base::FundamentalValue(true));
+  non_default_values_.push_back(base::MakeUnique<base::FundamentalValue>(true));
 
   // Integer prefs.
   pref_names_.push_back(
       chromeos::proxy_cros_settings_parser::kProxySingleHttpPort);
-  non_default_values_.push_back(new base::FundamentalValue(8080));
+  non_default_values_.push_back(base::MakeUnique<base::FundamentalValue>(8080));
 
   // String pref.
   pref_names_.push_back(chromeos::proxy_cros_settings_parser::kProxySingleHttp);
-  non_default_values_.push_back(new base::StringValue("127.0.0.1"));
+  non_default_values_.push_back(
+      base::MakeUnique<base::StringValue>("127.0.0.1"));
 
   // List pref.
   pref_names_.push_back(chromeos::proxy_cros_settings_parser::kProxyIgnoreList);
-  base::ListValue* list = new base::ListValue();
+  std::unique_ptr<base::ListValue> list = base::MakeUnique<base::ListValue>();
   list->AppendString("*.google.com");
   list->AppendString("1.2.3.4:22");
-  non_default_values_.push_back(list);
+  non_default_values_.push_back(std::move(list));
 
   // Verify that no policy is presented to the UI. This must be verified on the
   // kProxyType and the kUseSharedProxies prefs.
   pref_names_.push_back(chromeos::proxy_cros_settings_parser::kProxyType);
-  non_default_values_.push_back(new base::FundamentalValue(2));
+  non_default_values_.push_back(base::MakeUnique<base::FundamentalValue>(2));
 
   pref_names_.push_back(proxy_config::prefs::kUseSharedProxies);
-  non_default_values_.push_back(new base::FundamentalValue(false));
+  non_default_values_.push_back(
+      base::MakeUnique<base::FundamentalValue>(false));
 
   std::string observed_json;
   SetupJavaScriptTestEnvironment(pref_names_, &observed_json);
-  VerifyObservedPrefs(
-      observed_json, pref_names_, non_default_values_.get(), "", false, false);
+  VerifyObservedPrefs(observed_json, pref_names_, non_default_values_, "",
+                      false, false);
 }
 
 IN_PROC_BROWSER_TEST_F(ProxyPreferencesBrowserTest, ONCPolicy) {
   SetONCPolicy(policy::key::kOpenNetworkConfiguration,
                policy::POLICY_SCOPE_USER);
 
   // Verify that per-network policy is presented to the UI. This must be
   // verified on the kProxyType.
   pref_names_.push_back(chromeos::proxy_cros_settings_parser::kProxyType);
-  non_default_values_.push_back(new base::FundamentalValue(3));
+  non_default_values_.push_back(base::MakeUnique<base::FundamentalValue>(3));
 
   std::string observed_json;
   SetupJavaScriptTestEnvironment(pref_names_, &observed_json);
-  VerifyObservedPrefs(
-      observed_json, pref_names_, non_default_values_.get(),
-      "policy", true, false);
+  VerifyObservedPrefs(observed_json, pref_names_, non_default_values_, "policy",
+                      true, false);
 
   // Verify that 'use-shared-proxies' is not affected by per-network policy.
   pref_names_.clear();
   non_default_values_.clear();
   pref_names_.push_back(proxy_config::prefs::kUseSharedProxies);
-  non_default_values_.push_back(new base::FundamentalValue(false));
+  non_default_values_.push_back(
+      base::MakeUnique<base::FundamentalValue>(false));
 
   SetupJavaScriptTestEnvironment(pref_names_, &observed_json);
-  VerifyObservedPrefs(
-      observed_json, pref_names_, non_default_values_.get(), "", false, false);
+  VerifyObservedPrefs(observed_json, pref_names_, non_default_values_, "",
+                      false, false);
 }
 
 IN_PROC_BROWSER_TEST_F(ProxyPreferencesBrowserTest, DeviceONCPolicy) {
   SetONCPolicy(policy::key::kDeviceOpenNetworkConfiguration,
                policy::POLICY_SCOPE_MACHINE);
 
   // Verify that the policy is presented to the UI. This verification must be
   // done on the kProxyType pref.
   pref_names_.push_back(chromeos::proxy_cros_settings_parser::kProxyType);
-  non_default_values_.push_back(new base::FundamentalValue(3));
+  non_default_values_.push_back(base::MakeUnique<base::FundamentalValue>(3));
 
   std::string observed_json;
   SetupJavaScriptTestEnvironment(pref_names_, &observed_json);
-  VerifyObservedPrefs(
-      observed_json, pref_names_, non_default_values_.get(),
-      "policy", true, false);
+  VerifyObservedPrefs(observed_json, pref_names_, non_default_values_, "policy",
+                      true, false);
 
   // Verify that 'use-shared-proxies' is not affected by per-network policy.
   pref_names_.clear();
   non_default_values_.clear();
   pref_names_.push_back(proxy_config::prefs::kUseSharedProxies);
-  non_default_values_.push_back(new base::FundamentalValue(false));
+  non_default_values_.push_back(
+      base::MakeUnique<base::FundamentalValue>(false));
 
   SetupJavaScriptTestEnvironment(pref_names_, &observed_json);
-  VerifyObservedPrefs(
-      observed_json, pref_names_, non_default_values_.get(), "", false, false);
+  VerifyObservedPrefs(observed_json, pref_names_, non_default_values_, "",
+                      false, false);
 }
 
 IN_PROC_BROWSER_TEST_F(ProxyPreferencesBrowserTest, UserProxyPolicy) {
   policy_names_.push_back(policy::key::kProxyMode);
-  default_values_.push_back(
-      new base::StringValue(ProxyPrefs::kAutoDetectProxyModeName));
-  SetUserPolicies(
-      policy_names_, default_values_.get(), policy::POLICY_LEVEL_MANDATORY);
+  default_values_.push_back(base::MakeUnique<base::StringValue>(
+      ProxyPrefs::kAutoDetectProxyModeName));
+  SetUserPolicies(policy_names_, default_values_,
+                  policy::POLICY_LEVEL_MANDATORY);
   content::RunAllPendingInMessageLoop();
 
   // Verify that the policy is presented to the UI. This verification must be
   // done on the kProxyType pref.
   pref_names_.push_back(chromeos::proxy_cros_settings_parser::kProxyType);
-  non_default_values_.push_back(new base::FundamentalValue(3));
+  non_default_values_.push_back(base::MakeUnique<base::FundamentalValue>(3));
 
   // Verify that 'use-shared-proxies' is controlled by the policy.
   pref_names_.push_back(proxy_config::prefs::kUseSharedProxies);
-  non_default_values_.push_back(new base::FundamentalValue(false));
+  non_default_values_.push_back(
+      base::MakeUnique<base::FundamentalValue>(false));
 
   std::string observed_json;
   SetupJavaScriptTestEnvironment(pref_names_, &observed_json);
-  VerifyObservedPrefs(
-      observed_json, pref_names_, non_default_values_.get(),
-      "policy", true, false);
+  VerifyObservedPrefs(observed_json, pref_names_, non_default_values_, "policy",
+                      true, false);
 }
 
 // Verifies that modifications to the proxy settings are correctly pushed from
 // JavaScript to the ProxyConfig property stored in the network configuration.
 IN_PROC_BROWSER_TEST_F(ProxyPreferencesBrowserTest, ChromeOSSetProxy) {
   ASSERT_NO_FATAL_FAILURE(SetupJavaScriptTestEnvironment(pref_names_, NULL));
 
   SetProxyPref(chromeos::proxy_cros_settings_parser::kProxySingleHttpPort,
                base::FundamentalValue(123));
   SetProxyPref(chromeos::proxy_cros_settings_parser::kProxySingleHttp,
@@ skipping 36 matching lines @@
                base::FundamentalValue(3));
   SetProxyPref(chromeos::proxy_cros_settings_parser::kProxySocksPort,
                base::FundamentalValue(4));
 
   VerifyCurrentProxyServer(
       "http=a.com:1;https=4.3.2.1:2;ftp=c.com:3;socks=socks4://d.com:4",
       onc::ONC_SOURCE_NONE);
 }
 
 #endif