Move TestingPrefService to use unique_ptr<Value>

chrome/browser/content_settings/content_settings_policy_provider_unittest.cc

 // Copyright (c) 2011 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/content_settings/core/browser/content_settings_policy_provider.h"
 
 #include <memory>
 #include <string>
 
 #include "base/auto_reset.h"
 #include "base/command_line.h"
+#include "base/memory/ptr_util.h"
 #include "base/message_loop/message_loop.h"
 #include "base/test/scoped_feature_list.h"
 #include "chrome/browser/content_settings/content_settings_mock_observer.h"
 #include "chrome/common/chrome_switches.h"
 #include "chrome/common/url_constants.h"
 #include "chrome/test/base/testing_profile.h"
 #include "components/content_settings/core/browser/content_settings_rule.h"
 #include "components/content_settings/core/browser/content_settings_utils.h"
 #include "components/content_settings/core/common/content_settings_pattern.h"
 #include "components/content_settings/core/common/pref_names.h"
@@ skipping 19 matching lines @@
   sync_preferences::TestingPrefServiceSyncable* prefs =
       profile.GetTestingPrefService();
   PolicyProvider provider(prefs);
 
   std::unique_ptr<RuleIterator> rule_iterator(provider.GetRuleIterator(
       CONTENT_SETTINGS_TYPE_GEOLOCATION, std::string(), false));
   EXPECT_FALSE(rule_iterator);
 
   // Change the managed value of the default geolocation setting
   prefs->SetManagedPref(prefs::kManagedDefaultGeolocationSetting,
-                        new base::Value(CONTENT_SETTING_BLOCK));
+                        base::MakeUnique<base::Value>(CONTENT_SETTING_BLOCK));
 
   rule_iterator = provider.GetRuleIterator(CONTENT_SETTINGS_TYPE_GEOLOCATION,
                                            std::string(), false);
   ASSERT_TRUE(rule_iterator);
   EXPECT_TRUE(rule_iterator->HasNext());
   Rule rule = rule_iterator->Next();
   EXPECT_FALSE(rule_iterator->HasNext());
 
   EXPECT_EQ(ContentSettingsPattern::Wildcard(), rule.primary_pattern);
   EXPECT_EQ(ContentSettingsPattern::Wildcard(), rule.secondary_pattern);
   EXPECT_EQ(CONTENT_SETTING_BLOCK, ValueToContentSetting(rule.value.get()));
 
   provider.ShutdownOnUIThread();
 }
 
 TEST_F(PolicyProviderTest, ManagedDefaultContentSettings) {
   TestingProfile profile;
   sync_preferences::TestingPrefServiceSyncable* prefs =
       profile.GetTestingPrefService();
   PolicyProvider provider(prefs);
 
   prefs->SetManagedPref(prefs::kManagedDefaultPluginsSetting,
-                        new base::Value(CONTENT_SETTING_BLOCK));
+                        base::MakeUnique<base::Value>(CONTENT_SETTING_BLOCK));
 
   std::unique_ptr<RuleIterator> rule_iterator(provider.GetRuleIterator(
       CONTENT_SETTINGS_TYPE_PLUGINS, std::string(), false));
   EXPECT_TRUE(rule_iterator->HasNext());
   Rule rule = rule_iterator->Next();
   EXPECT_FALSE(rule_iterator->HasNext());
 
   EXPECT_EQ(ContentSettingsPattern::Wildcard(), rule.primary_pattern);
   EXPECT_EQ(ContentSettingsPattern::Wildcard(), rule.secondary_pattern);
   EXPECT_EQ(CONTENT_SETTING_BLOCK, ValueToContentSetting(rule.value.get()));
 
   provider.ShutdownOnUIThread();
 }
 
 TEST_F(PolicyProviderTest, ManagedDefaultPluginSettingsExperiment) {
   base::test::ScopedFeatureList scoped_feature_list;
   scoped_feature_list.InitFromCommandLine("IgnoreDefaultPluginsSetting",
                                           std::string());
 
   TestingProfile profile;
   sync_preferences::TestingPrefServiceSyncable* prefs =
       profile.GetTestingPrefService();
   PolicyProvider provider(prefs);
 
   // ForceDefaultPluginsSettingAsk overrides this to ASK.
   prefs->SetManagedPref(prefs::kManagedDefaultPluginsSetting,
-                        new base::Value(CONTENT_SETTING_BLOCK));
+                        base::MakeUnique<base::Value>(CONTENT_SETTING_BLOCK));
   prefs->SetManagedPref(prefs::kManagedDefaultJavaScriptSetting,
-                        new base::Value(CONTENT_SETTING_BLOCK));
+                        base::MakeUnique<base::Value>(CONTENT_SETTING_BLOCK));
 
   std::unique_ptr<RuleIterator> plugin_rule_iterator(provider.GetRuleIterator(
       CONTENT_SETTINGS_TYPE_PLUGINS, std::string(), false));
   // Policy should be removed when running under experiment.
   EXPECT_FALSE(plugin_rule_iterator);
 
   std::unique_ptr<RuleIterator> js_rule_iterator(provider.GetRuleIterator(
       CONTENT_SETTINGS_TYPE_JAVASCRIPT, std::string(), false));
   // Other policies should be left alone.
   EXPECT_TRUE(js_rule_iterator->HasNext());
@@ skipping 19 matching lines @@
   MockObserver mock_observer;
   EXPECT_CALL(mock_observer,
               OnContentSettingChanged(_,
                                       _,
                                       CONTENT_SETTINGS_TYPE_DEFAULT,
                                       ""));
   provider.AddObserver(&mock_observer);
 
   // Set the managed default-content-setting.
   prefs->SetManagedPref(prefs::kManagedDefaultImagesSetting,
-                        new base::Value(CONTENT_SETTING_BLOCK));
+                        base::MakeUnique<base::Value>(CONTENT_SETTING_BLOCK));
   ::testing::Mock::VerifyAndClearExpectations(&mock_observer);
   EXPECT_CALL(mock_observer,
               OnContentSettingChanged(_,
                                       _,
                                       CONTENT_SETTINGS_TYPE_DEFAULT,
                                       ""));
   // Remove the managed default-content-setting.
   prefs->RemoveManagedPref(prefs::kManagedDefaultImagesSetting);
   provider.ShutdownOnUIThread();
 }
 
 TEST_F(PolicyProviderTest, GettingManagedContentSettings) {
   TestingProfile profile;
   sync_preferences::TestingPrefServiceSyncable* prefs =
       profile.GetTestingPrefService();
 
-  base::ListValue* value = new base::ListValue();
+  auto value = base::MakeUnique<base::ListValue>();
   value->AppendString("[*.]google.com");
-  prefs->SetManagedPref(prefs::kManagedImagesBlockedForUrls,
-                        value);
+  prefs->SetManagedPref(prefs::kManagedImagesBlockedForUrls, std::move(value));
 
   PolicyProvider provider(prefs);
 
   ContentSettingsPattern yt_url_pattern =
       ContentSettingsPattern::FromString("www.youtube.com");
   GURL youtube_url("http://www.youtube.com");
   GURL google_url("http://mail.google.com");
 
   EXPECT_EQ(CONTENT_SETTING_DEFAULT,
             TestUtils::GetContentSetting(&provider, youtube_url, youtube_url,
@@ skipping 32 matching lines @@
                                          std::string(), false));
 
   provider.ShutdownOnUIThread();
 }
 
 TEST_F(PolicyProviderTest, ResourceIdentifier) {
   TestingProfile profile;
   sync_preferences::TestingPrefServiceSyncable* prefs =
       profile.GetTestingPrefService();
 
-  base::ListValue* value = new base::ListValue();
+  auto value = base::MakeUnique<base::ListValue>();
   value->AppendString("[*.]google.com");
-  prefs->SetManagedPref(prefs::kManagedPluginsAllowedForUrls,
-                        value);
+  prefs->SetManagedPref(prefs::kManagedPluginsAllowedForUrls, std::move(value));
 
   PolicyProvider provider(prefs);
 
   GURL youtube_url("http://www.youtube.com");
   GURL google_url("http://mail.google.com");
 
   EXPECT_EQ(CONTENT_SETTING_DEFAULT,
             TestUtils::GetContentSetting(&provider, youtube_url, youtube_url,
                                          CONTENT_SETTINGS_TYPE_PLUGINS,
                                          "someplugin", false));
@@ skipping 23 matching lines @@
   // Tests the default setting for auto selecting certificates
   EXPECT_EQ(NULL, TestUtils::GetContentSettingValue(
                       &provider, google_url, google_url,
                       CONTENT_SETTINGS_TYPE_AUTO_SELECT_CERTIFICATE,
                       std::string(), false));
 
   // Set the content settings pattern list for origins to auto select
   // certificates.
   std::string pattern_str("\"pattern\":\"[*.]google.com\"");
   std::string filter_str("\"filter\":{\"ISSUER\":{\"CN\":\"issuer name\"}}");
-  base::ListValue* value = new base::ListValue();
+  auto value = base::MakeUnique<base::ListValue>();
   value->AppendString("{" + pattern_str + "," + filter_str + "}");
   prefs->SetManagedPref(prefs::kManagedAutoSelectCertificateForUrls,
-                        value);
+                        std::move(value));
   GURL youtube_url("https://www.youtube.com");
   EXPECT_EQ(NULL, TestUtils::GetContentSettingValue(
                       &provider, youtube_url, youtube_url,
                       CONTENT_SETTINGS_TYPE_AUTO_SELECT_CERTIFICATE,
                       std::string(), false));
   std::unique_ptr<base::Value> cert_filter(TestUtils::GetContentSettingValue(
       &provider, google_url, google_url,
       CONTENT_SETTINGS_TYPE_AUTO_SELECT_CERTIFICATE, std::string(), false));
 
   ASSERT_EQ(base::Value::Type::DICTIONARY, cert_filter->GetType());
   base::DictionaryValue* dict_value =
       static_cast<base::DictionaryValue*>(cert_filter.get());
   std::string actual_common_name;
   ASSERT_TRUE(dict_value->GetString("ISSUER.CN", &actual_common_name));
   EXPECT_EQ("issuer name", actual_common_name);
   provider.ShutdownOnUIThread();
 }
 
 }  // namespace content_settings