Stop passing raw pointers to DictionaryValue::Set, part 2

chrome/browser/chromeos/extensions/device_local_account_management_policy_provider_unittest.cc

 // Copyright 2013 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/chromeos/extensions/device_local_account_management_policy_provider.h"
 
 #include <string>
 #include <utility>
 
 #include "base/files/file_path.h"
@@ skipping 40 matching lines @@
 scoped_refptr<const extensions::Extension> CreateExternalComponentExtension() {
   base::DictionaryValue values;
   return CreateExtensionFromValues(std::string(),
                                    extensions::Manifest::EXTERNAL_COMPONENT,
                                    &values,
                                    extensions::Extension::NO_FLAGS);
 }
 
 scoped_refptr<const extensions::Extension> CreateHostedApp() {
   base::DictionaryValue values;
-  values.Set(extensions::manifest_keys::kApp, new base::DictionaryValue);
-  values.Set(extensions::manifest_keys::kWebURLs, new base::ListValue);
+  values.Set(extensions::manifest_keys::kApp,
+             base::MakeUnique<base::DictionaryValue>());
+  values.Set(extensions::manifest_keys::kWebURLs,
+             base::MakeUnique<base::ListValue>());
   return CreateExtensionFromValues(std::string(),
                                    extensions::Manifest::INTERNAL,
                                    &values,
                                    extensions::Extension::NO_FLAGS);
 }
 
 scoped_refptr<const extensions::Extension> CreatePlatformAppWithExtraValues(
     const base::DictionaryValue* extra_values,
     extensions::Manifest::Location location,
     int flags) {
@@ skipping 94 matching lines @@
     EXPECT_FALSE(provider.UserMayLoad(extension.get(), &error));
     EXPECT_NE(base::string16(), error);
     error.clear();
   }
 
   // Verify that a platform app with all safe manifest entries can be installed.
   {
     base::DictionaryValue values;
     values.SetString(extensions::manifest_keys::kDescription, "something");
     values.SetString(extensions::manifest_keys::kShortName, "something else");
-    base::ListValue* permissions = new base::ListValue();
+    auto permissions = base::MakeUnique<base::ListValue>();
     permissions->AppendString("alarms");
     permissions->AppendString("background");
-    values.Set(extensions::manifest_keys::kPermissions, permissions);
-    base::ListValue* optional_permissions = new base::ListValue();
+    values.Set(extensions::manifest_keys::kPermissions, std::move(permissions));
+    auto optional_permissions = base::MakeUnique<base::ListValue>();
     optional_permissions->AppendString("alarms");
     optional_permissions->AppendString("background");
     values.Set(extensions::manifest_keys::kOptionalPermissions,
-               optional_permissions);
+               std::move(optional_permissions));
     extension = CreatePlatformAppWithExtraValues(
         &values,
         extensions::Manifest::EXTERNAL_POLICY,
         extensions::Extension::NO_FLAGS);
     ASSERT_TRUE(extension);
 
     EXPECT_TRUE(provider.UserMayLoad(extension.get(), &error));
     EXPECT_EQ(base::string16(), error);
     error.clear();
   }
@@ skipping 13 matching lines @@
     EXPECT_NE(base::string16(), error);
     error.clear();
   }
 
   // Verify that a platform app with an unsafe manifest entry cannot be
   // installed.  Since the program logic is based entirely on whitelists, there
   // is no significant advantage in testing all unsafe manifest entries
   // individually.
   {
     base::DictionaryValue values;
-    values.Set("chrome_settings_overrides", new base::DictionaryValue());
+    values.Set("chrome_settings_overrides",
+               base::MakeUnique<base::DictionaryValue>());
     extension = CreatePlatformAppWithExtraValues(
         &values,
         extensions::Manifest::EXTERNAL_POLICY,
         extensions::Extension::NO_FLAGS);
     ASSERT_TRUE(extension);
 
     EXPECT_FALSE(provider.UserMayLoad(extension.get(), &error));
     EXPECT_NE(base::string16(), error);
     error.clear();
   }
@@ skipping 27 matching lines @@
 
     EXPECT_TRUE(provider.UserMayLoad(extension.get(), &error));
     EXPECT_EQ(base::string16(), error);
     error.clear();
   }
 
   // Verify that a hosted app with a safe manifest entry under "app" can be
   // installed.
   {
     base::DictionaryValue values;
-    values.Set(extensions::manifest_keys::kApp, new base::DictionaryValue);
-    values.Set(extensions::manifest_keys::kWebURLs, new base::ListValue);
+    values.Set(extensions::manifest_keys::kApp,
+               base::MakeUnique<base::DictionaryValue>());
+    values.Set(extensions::manifest_keys::kWebURLs,
+               base::MakeUnique<base::ListValue>());
     values.SetString("app.content_security_policy", "something2");
     extension = CreateExtensionFromValues(
         std::string(),
         extensions::Manifest::EXTERNAL_POLICY,
         &values,
         extensions::Extension::NO_FLAGS);
     ASSERT_TRUE(extension);
 
     EXPECT_TRUE(provider.UserMayLoad(extension.get(), &error));
     EXPECT_EQ(base::string16(), error);
     error.clear();
   }
 
   // Verify that a theme with a safe manifest entry under "app" cannot be
   // installed.
   {
     base::DictionaryValue values;
-    values.Set("theme", new base::DictionaryValue());
+    values.Set("theme", base::MakeUnique<base::DictionaryValue>());
     values.SetString("app.content_security_policy", "something2");
     extension = CreateExtensionFromValues(
         std::string(),
         extensions::Manifest::EXTERNAL_POLICY,
         &values,
         extensions::Extension::NO_FLAGS);
     ASSERT_TRUE(extension);
 
     EXPECT_FALSE(provider.UserMayLoad(extension.get(), &error));
     EXPECT_NE(base::string16(), error);
     error.clear();
   }
 
   // Verify that a platform app with an unknown permission entry cannot be
   // installed.
   {
-    base::ListValue* const permissions = new base::ListValue();
+    auto permissions = base::MakeUnique<base::ListValue>();
     permissions->AppendString("not_whitelisted_permission");
     base::DictionaryValue values;
-    values.Set(extensions::manifest_keys::kPermissions, permissions);
+    values.Set(extensions::manifest_keys::kPermissions, std::move(permissions));
 
     extension = CreatePlatformAppWithExtraValues(
         &values,
         extensions::Manifest::EXTERNAL_POLICY,
         extensions::Extension::NO_FLAGS);
     ASSERT_TRUE(extension);
 
     EXPECT_FALSE(provider.UserMayLoad(extension.get(), &error));
     EXPECT_NE(base::string16(), error);
     error.clear();
   }
 
   // Verify that a platform app with an unsafe permission entry cannot be
   // installed.  Since the program logic is based entirely on whitelists, there
   // is no significant advantage in testing all unsafe permissions individually.
   {
-    base::ListValue* const permissions = new base::ListValue();
+    auto permissions = base::MakeUnique<base::ListValue>();
     permissions->AppendString("experimental");
     base::DictionaryValue values;
-    values.Set(extensions::manifest_keys::kPermissions, permissions);
+    values.Set(extensions::manifest_keys::kPermissions, std::move(permissions));
 
     extension = CreatePlatformAppWithExtraValues(
         &values,
         extensions::Manifest::EXTERNAL_POLICY,
         extensions::Extension::NO_FLAGS);
     ASSERT_TRUE(extension);
 
     EXPECT_FALSE(provider.UserMayLoad(extension.get(), &error));
     EXPECT_NE(base::string16(), error);
     error.clear();
   }
 
   // Verify that a platform app with an unsafe optional permission entry cannot
   // be installed.
   {
-    base::ListValue* const permissions = new base::ListValue();
+    auto permissions = base::MakeUnique<base::ListValue>();
     permissions->AppendString("experimental");
     base::DictionaryValue values;
-    values.Set(extensions::manifest_keys::kOptionalPermissions, permissions);
+    values.Set(extensions::manifest_keys::kOptionalPermissions,
+               std::move(permissions));
 
     extension = CreatePlatformAppWithExtraValues(
         &values,
         extensions::Manifest::EXTERNAL_POLICY,
         extensions::Extension::NO_FLAGS);
     ASSERT_TRUE(extension);
 
     EXPECT_FALSE(provider.UserMayLoad(extension.get(), &error));
     EXPECT_NE(base::string16(), error);
     error.clear();
   }
 
   // Verify that a platform app with an url_handlers manifest entry and which is
   // not installed through the web store cannot be installed.
   {
-    base::ListValue* const matches = new base::ListValue();
+    auto matches = base::MakeUnique<base::ListValue>();
     matches->AppendString("https://example.com/*");
     base::DictionaryValue values;
-    values.Set("url_handlers.example_com.matches", matches);
+    values.Set("url_handlers.example_com.matches", std::move(matches));
     values.SetString("url_handlers.example_com.title", "example title");
 
     extension = CreatePlatformAppWithExtraValues(
         &values,
         extensions::Manifest::EXTERNAL_POLICY,
         extensions::Extension::NO_FLAGS);
     ASSERT_TRUE(extension);
 
     EXPECT_FALSE(provider.UserMayLoad(extension.get(), &error));
     EXPECT_NE(base::string16(), error);
     error.clear();
   }
 
   // Verify that a platform app with a url_handlers manifest entry and which is
   // installed through the web store can be installed.
   {
-    base::ListValue* const matches = new base::ListValue();
+    auto matches = base::MakeUnique<base::ListValue>();
     matches->AppendString("https://example.com/*");
     base::DictionaryValue values;
-    values.Set("url_handlers.example_com.matches", matches);
+    values.Set("url_handlers.example_com.matches", std::move(matches));
     values.SetString("url_handlers.example_com.title", "example title");
 
     extension = CreatePlatformAppWithExtraValues(
         &values,
         extensions::Manifest::EXTERNAL_POLICY,
         extensions::Extension::FROM_WEBSTORE);
     ASSERT_TRUE(extension);
 
     EXPECT_TRUE(provider.UserMayLoad(extension.get(), &error));
     EXPECT_EQ(base::string16(), error);
     error.clear();
   }
 
   // Verify that a platform app with remote URL permissions can be installed.
   {
-    base::ListValue* const permissions = new base::ListValue();
+    auto permissions = base::MakeUnique<base::ListValue>();
     permissions->AppendString("https://example.com/");
     permissions->AppendString("http://example.com/");
     permissions->AppendString("ftp://example.com/");
     base::DictionaryValue values;
-    values.Set(extensions::manifest_keys::kPermissions, permissions);
+    values.Set(extensions::manifest_keys::kPermissions, std::move(permissions));
 
     extension = CreatePlatformAppWithExtraValues(
         &values,
         extensions::Manifest::EXTERNAL_POLICY,
         extensions::Extension::NO_FLAGS);
     ASSERT_TRUE(extension);
 
     EXPECT_TRUE(provider.UserMayLoad(extension.get(), &error));
     EXPECT_EQ(base::string16(), error);
     error.clear();
   }
 
   // Verify that an extension with remote URL permissions cannot be installed.
   {
-    base::ListValue* const permissions = new base::ListValue();
+    auto permissions = base::MakeUnique<base::ListValue>();
     permissions->AppendString("https://example.com/");
     permissions->AppendString("http://example.com/");
     permissions->AppendString("ftp://example.com/");
     base::DictionaryValue values;
-    values.Set(extensions::manifest_keys::kPermissions, permissions);
+    values.Set(extensions::manifest_keys::kPermissions, std::move(permissions));
 
     extension = CreateExtensionFromValues(
         std::string(),
         extensions::Manifest::EXTERNAL_POLICY,
         &values,
         extensions::Extension::NO_FLAGS);
     ASSERT_TRUE(extension);
 
     EXPECT_FALSE(provider.UserMayLoad(extension.get(), &error));
     EXPECT_NE(base::string16(), error);
     error.clear();
   }
 
   // Verify that a platform app with a local URL permission cannot be installed.
   {
-    base::ListValue* const permissions = new base::ListValue();
+    auto permissions = base::MakeUnique<base::ListValue>();
     permissions->AppendString("file:///some/where");
     base::DictionaryValue values;
-    values.Set(extensions::manifest_keys::kPermissions, permissions);
+    values.Set(extensions::manifest_keys::kPermissions, std::move(permissions));
 
     extension = CreatePlatformAppWithExtraValues(
         &values,
         extensions::Manifest::EXTERNAL_POLICY,
         extensions::Extension::NO_FLAGS);
     ASSERT_TRUE(extension);
 
     EXPECT_FALSE(provider.UserMayLoad(extension.get(), &error));
     EXPECT_NE(base::string16(), error);
     error.clear();
   }
 
   // Verify that a platform app with socket dictionary permission can be
   // installed.
   {
     auto socket = base::MakeUnique<base::DictionaryValue>();
-    base::ListValue* const tcp_list = new base::ListValue();
+    auto tcp_list = base::MakeUnique<base::ListValue>();
     tcp_list->AppendString("tcp-connect");
-    socket->Set("socket", tcp_list);
-    base::ListValue* const permissions = new base::ListValue();
+    socket->Set("socket", std::move(tcp_list));
+    auto permissions = base::MakeUnique<base::ListValue>();
     permissions->Append(std::move(socket));
     base::DictionaryValue values;
-    values.Set(extensions::manifest_keys::kPermissions, permissions);
+    values.Set(extensions::manifest_keys::kPermissions, std::move(permissions));
 
     extension = CreatePlatformAppWithExtraValues(
         &values,
         extensions::Manifest::EXTERNAL_POLICY,
         extensions::Extension::NO_FLAGS);
     ASSERT_TRUE(extension);
 
     EXPECT_TRUE(provider.UserMayLoad(extension.get(), &error));
     EXPECT_EQ(base::string16(), error);
     error.clear();
   }
 
   // Verify that a platform app with unknown dictionary permission cannot be
   // installed.
   {
     auto socket = base::MakeUnique<base::DictionaryValue>();
-    base::ListValue* const tcp_list = new base::ListValue();
+    auto tcp_list = base::MakeUnique<base::ListValue>();
     tcp_list->AppendString("unknown_value");
-    socket->Set("unknown_key", tcp_list);
-    base::ListValue* const permissions = new base::ListValue();
+    socket->Set("unknown_key", std::move(tcp_list));
+    auto permissions = base::MakeUnique<base::ListValue>();
     permissions->Append(std::move(socket));
     base::DictionaryValue values;
-    values.Set(extensions::manifest_keys::kPermissions, permissions);
+    values.Set(extensions::manifest_keys::kPermissions, std::move(permissions));
 
     extension = CreatePlatformAppWithExtraValues(
         &values,
         extensions::Manifest::EXTERNAL_POLICY,
         extensions::Extension::NO_FLAGS);
     ASSERT_TRUE(extension);
 
     EXPECT_FALSE(provider.UserMayLoad(extension.get(), &error));
     EXPECT_NE(base::string16(), error);
     error.clear();
@@ skipping 10 matching lines @@
     ASSERT_TRUE(extension);
 
     EXPECT_TRUE(provider.UserMayLoad(extension.get(), &error));
     EXPECT_EQ(base::string16(), error);
     error.clear();
   }
 
   // Verify that a shared_module can be installed.
   {
     base::DictionaryValue values;
-    values.Set("export.whitelist", new base::ListValue());
+    values.Set("export.whitelist", base::MakeUnique<base::ListValue>());
     extension = CreateExtensionFromValues(
         std::string(),
         extensions::Manifest::EXTERNAL_POLICY,
         &values,
         extensions::Extension::NO_FLAGS);
     ASSERT_TRUE(extension);
 
     EXPECT_TRUE(provider.UserMayLoad(extension.get(), &error));
     EXPECT_EQ(base::string16(), error);
     error.clear();
   }
 
   // Verify that a theme can be installed.
   {
     base::DictionaryValue values;
-    values.Set("theme", new base::DictionaryValue());
+    values.Set("theme", base::MakeUnique<base::DictionaryValue>());
     extension = CreateExtensionFromValues(
         std::string(),
         extensions::Manifest::EXTERNAL_POLICY,
         &values,
         extensions::Extension::NO_FLAGS);
     ASSERT_TRUE(extension);
 
     EXPECT_TRUE(provider.UserMayLoad(extension.get(), &error));
     EXPECT_EQ(base::string16(), error);
     error.clear();
@@ skipping 51 matching lines @@
   // types of device-local accounts cannot be installed in a single-app kiosk
   // session.
   extension = CreateRegularExtension(kWhitelistedId);
   ASSERT_TRUE(extension.get());
   EXPECT_TRUE(provider.UserMayLoad(extension.get(), &error));
   EXPECT_EQ(base::string16(), error);
   error.clear();
 }
 
 }  // namespace chromeos