Use std::unique_ptr to express ownership of base::Value in PolicyMap::Entry

components/policy/core/common/schema_registry_tracking_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 "components/policy/core/common/schema_registry_tracking_policy_provider.h"
 
 #include <memory>
 #include <string>
 #include <utility>
 
+#include "base/memory/ptr_util.h"
 #include "base/values.h"
 #include "components/policy/core/common/mock_configuration_policy_provider.h"
 #include "components/policy/core/common/policy_bundle.h"
 #include "components/policy/core/common/policy_map.h"
 #include "components/policy/core/common/policy_types.h"
 #include "components/policy/core/common/schema.h"
 #include "components/policy/core/common/schema_registry.h"
 #include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
@@ skipping 56 matching lines @@
   Mock::VerifyAndClearExpectations(&mock_provider_);
 
   const PolicyBundle empty_bundle;
   EXPECT_TRUE(
       schema_registry_tracking_provider_.policies().Equals(empty_bundle));
 }
 
 TEST_F(SchemaRegistryTrackingPolicyProviderTest, PassOnChromePolicy) {
   PolicyBundle bundle;
   const PolicyNamespace chrome_ns(POLICY_DOMAIN_CHROME, "");
-  bundle.Get(chrome_ns).Set("policy",
-                            POLICY_LEVEL_MANDATORY,
-                            POLICY_SCOPE_USER,
-                            POLICY_SOURCE_CLOUD,
-                            new base::StringValue("visible"),
-                            NULL);
+  bundle.Get(chrome_ns).Set(
+      "policy", POLICY_LEVEL_MANDATORY, POLICY_SCOPE_USER, POLICY_SOURCE_CLOUD,
+      base::WrapUnique(new base::StringValue("visible")), nullptr);
 
   EXPECT_CALL(observer_, OnUpdatePolicy(&schema_registry_tracking_provider_));
   std::unique_ptr<PolicyBundle> delegate_bundle(new PolicyBundle);
   delegate_bundle->CopyFrom(bundle);
   delegate_bundle->Get(PolicyNamespace(POLICY_DOMAIN_EXTENSIONS, "xyz"))
-      .Set("foo",
-           POLICY_LEVEL_MANDATORY,
-           POLICY_SCOPE_USER,
+      .Set("foo", POLICY_LEVEL_MANDATORY, POLICY_SCOPE_USER,
            POLICY_SOURCE_CLOUD,
-           new base::StringValue("not visible"),
-           NULL);
+           base::WrapUnique(new base::StringValue("not visible")), nullptr);
   mock_provider_.UpdatePolicy(std::move(delegate_bundle));
   Mock::VerifyAndClearExpectations(&observer_);
 
   EXPECT_FALSE(schema_registry_tracking_provider_.IsInitializationComplete(
       POLICY_DOMAIN_EXTENSIONS));
   EXPECT_TRUE(schema_registry_tracking_provider_.policies().Equals(bundle));
 }
 
 TEST_F(SchemaRegistryTrackingPolicyProviderTest, RefreshPolicies) {
   EXPECT_CALL(mock_provider_, RefreshPolicies());
   schema_registry_tracking_provider_.RefreshPolicies();
   Mock::VerifyAndClearExpectations(&mock_provider_);
 }
 
 TEST_F(SchemaRegistryTrackingPolicyProviderTest, SchemaReady) {
   EXPECT_CALL(observer_, OnUpdatePolicy(&schema_registry_tracking_provider_));
   schema_registry_.SetReady(POLICY_DOMAIN_CHROME);
   schema_registry_.SetReady(POLICY_DOMAIN_EXTENSIONS);
   Mock::VerifyAndClearExpectations(&observer_);
 
   EXPECT_TRUE(schema_registry_tracking_provider_.IsInitializationComplete(
       policy::POLICY_DOMAIN_EXTENSIONS));
 }
 
 TEST_F(SchemaRegistryTrackingPolicyProviderTest, SchemaReadyWithComponents) {
   PolicyMap policy_map;
-  policy_map.Set("foo",
-                 POLICY_LEVEL_MANDATORY,
-                 POLICY_SCOPE_USER,
+  policy_map.Set("foo", POLICY_LEVEL_MANDATORY, POLICY_SCOPE_USER,
                  POLICY_SOURCE_CLOUD,
-                 new base::StringValue("omg"),
-                 NULL);
+                 base::WrapUnique(new base::StringValue("omg")), nullptr);
   std::unique_ptr<PolicyBundle> bundle(new PolicyBundle);
   bundle->Get(PolicyNamespace(POLICY_DOMAIN_CHROME, "")).CopyFrom(policy_map);
   bundle->Get(PolicyNamespace(POLICY_DOMAIN_EXTENSIONS, "xyz"))
       .CopyFrom(policy_map);
   EXPECT_CALL(observer_, OnUpdatePolicy(&schema_registry_tracking_provider_));
   mock_provider_.UpdatePolicy(std::move(bundle));
   Mock::VerifyAndClearExpectations(&observer_);
 
   EXPECT_CALL(mock_provider_, RefreshPolicies()).Times(0);
   schema_registry_.RegisterComponent(
@@ skipping 26 matching lines @@
 }
 
 TEST_F(SchemaRegistryTrackingPolicyProviderTest, DelegateUpdates) {
   schema_registry_.RegisterComponent(
       PolicyNamespace(POLICY_DOMAIN_EXTENSIONS, "xyz"), CreateTestSchema());
   EXPECT_FALSE(schema_registry_.IsReady());
   EXPECT_FALSE(schema_registry_tracking_provider_.IsInitializationComplete(
       policy::POLICY_DOMAIN_EXTENSIONS));
 
   PolicyMap policy_map;
-  policy_map.Set("foo",
-                 POLICY_LEVEL_MANDATORY,
-                 POLICY_SCOPE_USER,
+  policy_map.Set("foo", POLICY_LEVEL_MANDATORY, POLICY_SCOPE_USER,
                  POLICY_SOURCE_CLOUD,
-                 new base::StringValue("omg"),
-                 NULL);
+                 base::WrapUnique(new base::StringValue("omg")), nullptr);
   // Chrome policy updates are visible even if the components aren't ready.
   EXPECT_CALL(observer_, OnUpdatePolicy(&schema_registry_tracking_provider_));
   mock_provider_.UpdateChromePolicy(policy_map);
   Mock::VerifyAndClearExpectations(&observer_);
 
   EXPECT_CALL(mock_provider_, RefreshPolicies());
   schema_registry_.SetReady(POLICY_DOMAIN_CHROME);
   schema_registry_.SetReady(POLICY_DOMAIN_EXTENSIONS);
   EXPECT_TRUE(schema_registry_.IsReady());
   Mock::VerifyAndClearExpectations(&mock_provider_);
@@ skipping 18 matching lines @@
 TEST_F(SchemaRegistryTrackingPolicyProviderTest, RemoveAndAddComponent) {
   EXPECT_CALL(mock_provider_, RefreshPolicies());
   const PolicyNamespace ns(POLICY_DOMAIN_EXTENSIONS, "xyz");
   schema_registry_.SetReady(POLICY_DOMAIN_CHROME);
   schema_registry_.RegisterComponent(ns, CreateTestSchema());
   schema_registry_.SetReady(POLICY_DOMAIN_EXTENSIONS);
   Mock::VerifyAndClearExpectations(&mock_provider_);
 
   // Serve policy for |ns|.
   PolicyBundle platform_policy;
-  platform_policy.Get(ns).Set("foo",
-                              POLICY_LEVEL_MANDATORY,
-                              POLICY_SCOPE_USER,
-                              POLICY_SOURCE_CLOUD,
-                              new base::StringValue("omg"),
-                              NULL);
+  platform_policy.Get(ns).Set(
+      "foo", POLICY_LEVEL_MANDATORY, POLICY_SCOPE_USER, POLICY_SOURCE_CLOUD,
+      base::WrapUnique(new base::StringValue("omg")), nullptr);
   std::unique_ptr<PolicyBundle> copy(new PolicyBundle);
   copy->CopyFrom(platform_policy);
   EXPECT_CALL(observer_, OnUpdatePolicy(_));
   mock_provider_.UpdatePolicy(std::move(copy));
   Mock::VerifyAndClearExpectations(&observer_);
   EXPECT_TRUE(
       schema_registry_tracking_provider_.policies().Equals(platform_policy));
 
   // Now remove that component.
   EXPECT_CALL(observer_, OnUpdatePolicy(_));
@@ skipping 11 matching lines @@
   EXPECT_CALL(observer_, OnUpdatePolicy(_));
   copy.reset(new PolicyBundle);
   copy->CopyFrom(platform_policy);
   mock_provider_.UpdatePolicy(std::move(copy));
   Mock::VerifyAndClearExpectations(&observer_);
   EXPECT_TRUE(
       schema_registry_tracking_provider_.policies().Equals(platform_policy));
 }
 
 }  // namespace policy