Move TestingPrefService to use unique_ptr<Value>

chrome/browser/extensions/extension_management_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 "chrome/browser/extensions/extension_management.h"
 
 #include <algorithm>
 #include <memory>
 #include <string>
 #include <vector>
@@ skipping 83 matching lines @@
     pref_service_->registry()->RegisterListPref(pref_names::kInstallDenyList);
     pref_service_->registry()->RegisterListPref(pref_names::kInstallAllowList);
     pref_service_->registry()->RegisterDictionaryPref(
         pref_names::kInstallForceList);
     pref_service_->registry()->RegisterDictionaryPref(
         pref_names::kExtensionManagement);
     extension_management_.reset(
         new ExtensionManagement(pref_service_.get(), false));
   }
 
-  void SetPref(bool managed, const char* path, base::Value* value) {
+  void SetPref(bool managed,
+               const char* path,
+               std::unique_ptr<base::Value> value) {
     if (managed)
-      pref_service_->SetManagedPref(path, value);
+      pref_service_->SetManagedPref(path, std::move(value));
     else
-      pref_service_->SetUserPref(path, value);
+      pref_service_->SetUserPref(path, std::move(value));
   }
 
   void RemovePref(bool managed, const char* path) {
     if (managed)
       pref_service_->RemoveManagedPref(path);
     else
       pref_service_->RemoveUserPref(path);
   }
 
   const internal::GlobalSettings* ReadGlobalSettings() {
@@ skipping 30 matching lines @@
     return GetBlockedAPIPermissions(kNonExistingExtension, update_url);
   }
 
   void SetExampleDictPref() {
     std::string error_msg;
     std::unique_ptr<base::Value> parsed = base::JSONReader::ReadAndReturnError(
         kExampleDictPreference,
         base::JSONParserOptions::JSON_ALLOW_TRAILING_COMMAS, NULL, &error_msg);
     ASSERT_TRUE(parsed && parsed->IsType(base::Value::Type::DICTIONARY))
         << error_msg;
-    SetPref(true, pref_names::kExtensionManagement, parsed.release());
+    SetPref(true, pref_names::kExtensionManagement, std::move(parsed));
   }
 
   // Wrapper of ExtensionManagement::GetInstallationMode, |id| and
   // |update_url| are used to construct an Extension for testing.
   ExtensionManagement::InstallationMode GetInstallationMode(
       const std::string& id,
       const std::string& update_url) {
     scoped_refptr<const Extension> extension =
         CreateExtension(Manifest::UNPACKED, "0.1", id, update_url);
     return extension_management_->GetInstallationMode(extension.get());
@@ skipping 93 matching lines @@
 
  protected:
   std::unique_ptr<StandardManagementPolicyProvider> provider_;
   scoped_refptr<Extension> extension_;
 };
 
 bool ExtensionAdminPolicyTest::BlacklistedByDefault(
     const base::ListValue* blacklist) {
   SetUpPolicyProvider();
   if (blacklist)
-    SetPref(true, pref_names::kInstallDenyList, blacklist->DeepCopy());
+    SetPref(true, pref_names::kInstallDenyList, blacklist->CreateDeepCopy());
   return extension_management_->BlacklistedByDefault();
 }
 
 bool ExtensionAdminPolicyTest::UserMayLoad(
     const base::ListValue* blacklist,
     const base::ListValue* whitelist,
     const base::DictionaryValue* forcelist,
     const base::ListValue* allowed_types,
     const Extension* extension,
     base::string16* error) {
   SetUpPolicyProvider();
   if (blacklist)
-    SetPref(true, pref_names::kInstallDenyList, blacklist->DeepCopy());
+    SetPref(true, pref_names::kInstallDenyList, blacklist->CreateDeepCopy());
   if (whitelist)
-    SetPref(true, pref_names::kInstallAllowList, whitelist->DeepCopy());
+    SetPref(true, pref_names::kInstallAllowList, whitelist->CreateDeepCopy());
   if (forcelist)
-    SetPref(true, pref_names::kInstallForceList, forcelist->DeepCopy());
+    SetPref(true, pref_names::kInstallForceList, forcelist->CreateDeepCopy());
   if (allowed_types)
-    SetPref(true, pref_names::kAllowedTypes, allowed_types->DeepCopy());
+    SetPref(true, pref_names::kAllowedTypes, allowed_types->CreateDeepCopy());
   return provider_->UserMayLoad(extension, error);
 }
 
 bool ExtensionAdminPolicyTest::UserMayModifySettings(const Extension* extension,
                                                      base::string16* error) {
   SetUpPolicyProvider();
   return provider_->UserMayModifySettings(extension, error);
 }
 
 bool ExtensionAdminPolicyTest::MustRemainEnabled(const Extension* extension,
                                                  base::string16* error) {
   SetUpPolicyProvider();
   return provider_->MustRemainEnabled(extension, error);
 }
 
 // Verify that preference controlled by legacy ExtensionInstallSources policy is
 // handled well.
 TEST_F(ExtensionManagementServiceTest, LegacyInstallSources) {
   base::ListValue allowed_sites_pref;
   allowed_sites_pref.AppendString("https://www.example.com/foo");
   allowed_sites_pref.AppendString("https://corp.mycompany.com/*");
-  SetPref(
-      true, pref_names::kAllowedInstallSites, allowed_sites_pref.DeepCopy());
+  SetPref(true, pref_names::kAllowedInstallSites,
+          allowed_sites_pref.CreateDeepCopy());
   const URLPatternSet& allowed_sites = ReadGlobalSettings()->install_sources;
   ASSERT_TRUE(ReadGlobalSettings()->has_restricted_install_sources);
   EXPECT_FALSE(allowed_sites.is_empty());
   EXPECT_TRUE(allowed_sites.MatchesURL(GURL("https://www.example.com/foo")));
   EXPECT_FALSE(allowed_sites.MatchesURL(GURL("https://www.example.com/bar")));
   EXPECT_TRUE(
       allowed_sites.MatchesURL(GURL("https://corp.mycompany.com/entry")));
   EXPECT_FALSE(
       allowed_sites.MatchesURL(GURL("https://www.mycompany.com/entry")));
 }
 
 // Verify that preference controlled by legacy ExtensionAllowedTypes policy is
 // handled well.
 TEST_F(ExtensionManagementServiceTest, LegacyAllowedTypes) {
   base::ListValue allowed_types_pref;
   allowed_types_pref.AppendInteger(Manifest::TYPE_THEME);
   allowed_types_pref.AppendInteger(Manifest::TYPE_USER_SCRIPT);
 
-  SetPref(true, pref_names::kAllowedTypes, allowed_types_pref.DeepCopy());
+  SetPref(true, pref_names::kAllowedTypes, allowed_types_pref.CreateDeepCopy());
   const std::vector<Manifest::Type>& allowed_types =
       ReadGlobalSettings()->allowed_types;
   ASSERT_TRUE(ReadGlobalSettings()->has_restricted_allowed_types);
   EXPECT_EQ(allowed_types.size(), 2u);
   EXPECT_FALSE(std::find(allowed_types.begin(),
                          allowed_types.end(),
                          Manifest::TYPE_EXTENSION) != allowed_types.end());
   EXPECT_TRUE(std::find(allowed_types.begin(),
                         allowed_types.end(),
                         Manifest::TYPE_THEME) != allowed_types.end());
   EXPECT_TRUE(std::find(allowed_types.begin(),
                    allowed_types.end(),
                    Manifest::TYPE_USER_SCRIPT) != allowed_types.end());
 }
 
 // Verify that preference controlled by legacy ExtensionInstallBlacklist policy
 // is handled well.
 TEST_F(ExtensionManagementServiceTest, LegacyInstallBlacklist) {
   base::ListValue denied_list_pref;
   denied_list_pref.AppendString(kTargetExtension);
 
-  SetPref(true, pref_names::kInstallDenyList, denied_list_pref.DeepCopy());
+  SetPref(true, pref_names::kInstallDenyList,
+          denied_list_pref.CreateDeepCopy());
   EXPECT_EQ(GetInstallationModeById(kTargetExtension),
             ExtensionManagement::INSTALLATION_BLOCKED);
   EXPECT_EQ(GetInstallationModeById(kNonExistingExtension),
             ExtensionManagement::INSTALLATION_ALLOWED);
 }
 
 // Verify that preference controlled by legacy ExtensionInstallWhitelist policy
 // is handled well.
 TEST_F(ExtensionManagementServiceTest, LegacyInstallWhitelist) {
   base::ListValue denied_list_pref;
   denied_list_pref.AppendString("*");
   base::ListValue allowed_list_pref;
   allowed_list_pref.AppendString(kTargetExtension);
 
-  SetPref(true, pref_names::kInstallDenyList, denied_list_pref.DeepCopy());
-  SetPref(true, pref_names::kInstallAllowList, allowed_list_pref.DeepCopy());
+  SetPref(true, pref_names::kInstallDenyList,
+          denied_list_pref.CreateDeepCopy());
+  SetPref(true, pref_names::kInstallAllowList,
+          allowed_list_pref.CreateDeepCopy());
   EXPECT_EQ(GetInstallationModeById(kTargetExtension),
             ExtensionManagement::INSTALLATION_ALLOWED);
   EXPECT_EQ(GetInstallationModeById(kNonExistingExtension),
             ExtensionManagement::INSTALLATION_BLOCKED);
 
   // Verify that install whitelist preference set by user is ignored.
   RemovePref(true, pref_names::kInstallAllowList);
-  SetPref(false, pref_names::kInstallAllowList, allowed_list_pref.DeepCopy());
+  SetPref(false, pref_names::kInstallAllowList,
+          allowed_list_pref.CreateDeepCopy());
   EXPECT_EQ(GetInstallationModeById(kTargetExtension),
             ExtensionManagement::INSTALLATION_BLOCKED);
 }
 
 // Verify that preference controlled by legacy ExtensionInstallForcelist policy
 // is handled well.
 TEST_F(ExtensionManagementServiceTest, LegacyInstallForcelist) {
   base::DictionaryValue forced_list_pref;
   ExternalPolicyLoader::AddExtension(
       &forced_list_pref, kTargetExtension, kExampleUpdateUrl);
 
-  SetPref(true, pref_names::kInstallForceList, forced_list_pref.DeepCopy());
+  SetPref(true, pref_names::kInstallForceList,
+          forced_list_pref.CreateDeepCopy());
   EXPECT_EQ(GetInstallationModeById(kTargetExtension),
             ExtensionManagement::INSTALLATION_FORCED);
   CheckAutomaticallyInstalledUpdateUrl(kTargetExtension, kExampleUpdateUrl);
   EXPECT_EQ(GetInstallationModeById(kNonExistingExtension),
             ExtensionManagement::INSTALLATION_ALLOWED);
 
   // Verify that install forcelist preference set by user is ignored.
   RemovePref(true, pref_names::kInstallForceList);
-  SetPref(false, pref_names::kInstallForceList, forced_list_pref.DeepCopy());
+  SetPref(false, pref_names::kInstallForceList,
+          forced_list_pref.CreateDeepCopy());
   EXPECT_EQ(GetInstallationModeById(kTargetExtension),
             ExtensionManagement::INSTALLATION_ALLOWED);
 }
 
 // Tests parsing of new dictionary preference.
 TEST_F(ExtensionManagementServiceTest, PreferenceParsing) {
   SetExampleDictPref();
 
   // Verifies the installation mode settings.
   EXPECT_TRUE(extension_management_->BlacklistedByDefault());
@@ skipping 128 matching lines @@
   EXPECT_TRUE(CheckMinimumVersion(kTargetExtension, "3.0.1"));
   EXPECT_TRUE(CheckMinimumVersion(kTargetExtension, "4.0"));
 }
 
 // Tests functionality of new preference as to deprecate legacy
 // ExtensionInstallSources policy.
 TEST_F(ExtensionManagementServiceTest, NewInstallSources) {
   // Set the legacy preference, and verifies that it works.
   base::ListValue allowed_sites_pref;
   allowed_sites_pref.AppendString("https://www.example.com/foo");
-  SetPref(
-      true, pref_names::kAllowedInstallSites, allowed_sites_pref.DeepCopy());
+  SetPref(true, pref_names::kAllowedInstallSites,
+          allowed_sites_pref.CreateDeepCopy());
   EXPECT_TRUE(ReadGlobalSettings()->has_restricted_install_sources);
   EXPECT_TRUE(ReadGlobalSettings()->install_sources.MatchesURL(
       GURL("https://www.example.com/foo")));
 
   // Set the new dictionary preference.
   {
     PrefUpdater updater(pref_service_.get());
     updater.ClearInstallSources();
   }
   // Verifies that the new one overrides the legacy ones.
@@ skipping 10 matching lines @@
   EXPECT_TRUE(ReadGlobalSettings()->install_sources.MatchesURL(
       GURL("https://corp.mycompany.com/entry")));
 }
 
 // Tests functionality of new preference as to deprecate legacy
 // ExtensionAllowedTypes policy.
 TEST_F(ExtensionManagementServiceTest, NewAllowedTypes) {
   // Set the legacy preference, and verifies that it works.
   base::ListValue allowed_types_pref;
   allowed_types_pref.AppendInteger(Manifest::TYPE_USER_SCRIPT);
-  SetPref(true, pref_names::kAllowedTypes, allowed_types_pref.DeepCopy());
+  SetPref(true, pref_names::kAllowedTypes, allowed_types_pref.CreateDeepCopy());
   EXPECT_TRUE(ReadGlobalSettings()->has_restricted_allowed_types);
   EXPECT_EQ(ReadGlobalSettings()->allowed_types.size(), 1u);
   EXPECT_EQ(ReadGlobalSettings()->allowed_types[0], Manifest::TYPE_USER_SCRIPT);
 
   // Set the new dictionary preference.
   {
     PrefUpdater updater(pref_service_.get());
     updater.ClearAllowedTypes();
   }
   // Verifies that the new one overrides the legacy ones.
@@ skipping 23 matching lines @@
   EXPECT_FALSE(extension_management_->BlacklistedByDefault());
   EXPECT_EQ(GetInstallationModeById(kTargetExtension),
             ExtensionManagement::INSTALLATION_BLOCKED);
   EXPECT_EQ(GetInstallationModeById(kNonExistingExtension),
             ExtensionManagement::INSTALLATION_ALLOWED);
 
   // Set legacy preference.
   base::ListValue denied_list_pref;
   denied_list_pref.AppendString("*");
   denied_list_pref.AppendString(kTargetExtension2);
-  SetPref(true, pref_names::kInstallDenyList, denied_list_pref.DeepCopy());
+  SetPref(true, pref_names::kInstallDenyList,
+          denied_list_pref.CreateDeepCopy());
 
   base::ListValue allowed_list_pref;
   allowed_list_pref.AppendString(kTargetExtension);
-  SetPref(true, pref_names::kInstallAllowList, allowed_list_pref.DeepCopy());
+  SetPref(true, pref_names::kInstallAllowList,
+          allowed_list_pref.CreateDeepCopy());
 
   // Verifies that the new one have higher priority over the legacy ones.
   EXPECT_FALSE(extension_management_->BlacklistedByDefault());
   EXPECT_EQ(GetInstallationModeById(kTargetExtension),
             ExtensionManagement::INSTALLATION_BLOCKED);
   EXPECT_EQ(GetInstallationModeById(kTargetExtension2),
             ExtensionManagement::INSTALLATION_BLOCKED);
   EXPECT_EQ(GetInstallationModeById(kNonExistingExtension),
             ExtensionManagement::INSTALLATION_ALLOWED);
 }
@@ skipping 10 matching lines @@
   }
   EXPECT_TRUE(extension_management_->BlacklistedByDefault());
   EXPECT_EQ(GetInstallationModeById(kTargetExtension),
             ExtensionManagement::INSTALLATION_ALLOWED);
   EXPECT_EQ(GetInstallationModeById(kNonExistingExtension),
             ExtensionManagement::INSTALLATION_BLOCKED);
 
   // Set legacy preference.
   base::ListValue denied_list_pref;
   denied_list_pref.AppendString(kTargetExtension);
-  SetPref(true, pref_names::kInstallDenyList, denied_list_pref.DeepCopy());
+  SetPref(true, pref_names::kInstallDenyList,
+          denied_list_pref.CreateDeepCopy());
 
   base::ListValue allowed_list_pref;
   allowed_list_pref.AppendString(kTargetExtension2);
-  SetPref(true, pref_names::kInstallAllowList, allowed_list_pref.DeepCopy());
+  SetPref(true, pref_names::kInstallAllowList,
+          allowed_list_pref.CreateDeepCopy());
 
   // Verifies that the new one have higher priority over the legacy ones.
   EXPECT_TRUE(extension_management_->BlacklistedByDefault());
   EXPECT_EQ(GetInstallationModeById(kTargetExtension),
             ExtensionManagement::INSTALLATION_ALLOWED);
   EXPECT_EQ(GetInstallationModeById(kTargetExtension2),
             ExtensionManagement::INSTALLATION_ALLOWED);
   EXPECT_EQ(GetInstallationModeById(kNonExistingExtension),
             ExtensionManagement::INSTALLATION_BLOCKED);
 }
 
 // Tests functionality of new preference as to deprecate legacy
 // ExtensionInstallForcelist policy.
 TEST_F(ExtensionManagementServiceTest, NewInstallForcelist) {
   // Set some legacy preferences, to verify that the new one overrides the
   // legacy ones.
   base::ListValue denied_list_pref;
   denied_list_pref.AppendString(kTargetExtension);
-  SetPref(true, pref_names::kInstallDenyList, denied_list_pref.DeepCopy());
+  SetPref(true, pref_names::kInstallDenyList,
+          denied_list_pref.CreateDeepCopy());
 
   // Set the new dictionary preference.
   {
     PrefUpdater updater(pref_service_.get());
     updater.SetIndividualExtensionAutoInstalled(
         kTargetExtension, kExampleUpdateUrl, true);
   }
   EXPECT_EQ(GetInstallationModeById(kTargetExtension),
             ExtensionManagement::INSTALLATION_FORCED);
   CheckAutomaticallyInstalledUpdateUrl(kTargetExtension, kExampleUpdateUrl);
@@ skipping 180 matching lines @@
   EXPECT_FALSE(error.empty());
 
   CreateExtension(Manifest::INTERNAL);
   error.clear();
   EXPECT_FALSE(MustRemainEnabled(extension_.get(), NULL));
   EXPECT_FALSE(MustRemainEnabled(extension_.get(), &error));
   EXPECT_TRUE(error.empty());
 }
 
 }  // namespace extensions