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

chrome/browser/chromeos/policy/network_configuration_updater_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 <stddef.h>
 
 #include <memory>
 #include <utility>
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/callback.h"
 #include "base/files/file_path.h"
 #include "base/macros.h"
+#include "base/memory/ptr_util.h"
 #include "base/run_loop.h"
 #include "base/values.h"
 #include "chrome/browser/chromeos/policy/device_network_configuration_updater.h"
 #include "chrome/browser/chromeos/policy/user_network_configuration_updater.h"
 #include "chrome/browser/chromeos/settings/cros_settings.h"
 #include "chrome/browser/chromeos/settings/scoped_cros_settings_test_helper.h"
 #include "chrome/test/base/testing_profile.h"
 #include "chromeos/network/fake_network_device_handler.h"
 #include "chromeos/network/mock_managed_network_configuration_handler.h"
 #include "chromeos/network/onc/onc_certificate_importer.h"
@@ skipping 317 matching lines @@
 
   base::DictionaryValue* global_config_repaired = NULL;
   onc_repaired->GetDictionaryWithoutPathExpansion(
       onc::toplevel_config::kGlobalNetworkConfiguration,
       &global_config_repaired);
   ASSERT_TRUE(global_config_repaired);
 
   std::string onc_policy =
       chromeos::onc::test_utils::ReadTestData("toplevel_partially_invalid.onc");
   PolicyMap policy;
-  policy.Set(key::kOpenNetworkConfiguration,
-             POLICY_LEVEL_MANDATORY,
-             POLICY_SCOPE_USER,
-             POLICY_SOURCE_CLOUD,
-             new base::StringValue(onc_policy),
-             NULL);
+  policy.Set(key::kOpenNetworkConfiguration, POLICY_LEVEL_MANDATORY,
+             POLICY_SCOPE_USER, POLICY_SOURCE_CLOUD,
+             base::WrapUnique(new base::StringValue(onc_policy)), nullptr);
   UpdateProviderPolicy(policy);
 
   EXPECT_CALL(network_config_handler_,
               SetPolicy(onc::ONC_SOURCE_USER_POLICY,
                         _,
                         IsEqualTo(network_configs_repaired),
                         IsEqualTo(global_config_repaired)));
   certificate_importer_->SetExpectedONCSource(onc::ONC_SOURCE_USER_POLICY);
 
   CreateNetworkConfigurationUpdaterForUserPolicy(
@@ skipping 98 matching lines @@
   cert_list =
       net::CreateCertificateListFromFile(net::GetTestCertsDirectory(),
                                          "ok_cert.pem",
                                          net::X509Certificate::FORMAT_AUTO);
   ASSERT_EQ(1u, cert_list.size());
   certificate_importer_->SetTrustedCertificatesResult(cert_list);
 
   // Change to any non-empty policy, so that updates are triggered. The actual
   // content of the policy is irrelevant.
   PolicyMap policy;
-  policy.Set(key::kOpenNetworkConfiguration,
-             POLICY_LEVEL_MANDATORY,
-             POLICY_SCOPE_USER,
-             POLICY_SOURCE_CLOUD,
-             new base::StringValue(kFakeONC),
-             NULL);
+  policy.Set(key::kOpenNetworkConfiguration, POLICY_LEVEL_MANDATORY,
+             POLICY_SCOPE_USER, POLICY_SOURCE_CLOUD,
+             base::WrapUnique(new base::StringValue(kFakeONC)), nullptr);
   UpdateProviderPolicy(policy);
   base::RunLoop().RunUntilIdle();
 
   // Certificates with the "Web" trust flag set will be returned and forwarded
   // to observers.
   {
     net::CertificateList trust_anchors;
     updater->GetWebTrustedCertificates(&trust_anchors);
     EXPECT_EQ(1u, trust_anchors.size());
   }
   EXPECT_EQ(1u, observer.trust_anchors_.size());
 
   updater->RemoveTrustedCertsObserver(&observer);
 }
 
 TEST_F(NetworkConfigurationUpdaterTest,
        DontImportCertificateBeforeCertificateImporterSet) {
   PolicyMap policy;
   policy.Set(key::kOpenNetworkConfiguration, POLICY_LEVEL_MANDATORY,
              POLICY_SCOPE_USER, POLICY_SOURCE_CLOUD,
-             new base::StringValue(kFakeONC), nullptr);
+             base::WrapUnique(new base::StringValue(kFakeONC)), nullptr);
   UpdateProviderPolicy(policy);
 
   EXPECT_CALL(network_config_handler_,
               SetPolicy(onc::ONC_SOURCE_USER_POLICY,
                         kFakeUsernameHash,
                         IsEqualTo(&fake_network_configs_),
                         IsEqualTo(&fake_global_network_config_)));
 
   UserNetworkConfigurationUpdater* updater =
       CreateNetworkConfigurationUpdaterForUserPolicy(
@@ skipping 46 matching lines @@
           true /* set certificate importer */);
     } else {
       CreateNetworkConfigurationUpdaterForDevicePolicy();
     }
   }
 };
 
 TEST_P(NetworkConfigurationUpdaterTestWithParam, InitialUpdates) {
   PolicyMap policy;
   policy.Set(GetParam(), POLICY_LEVEL_MANDATORY, POLICY_SCOPE_USER,
-             POLICY_SOURCE_CLOUD, new base::StringValue(kFakeONC), nullptr);
+             POLICY_SOURCE_CLOUD,
+             base::WrapUnique(new base::StringValue(kFakeONC)), nullptr);
   UpdateProviderPolicy(policy);
 
   EXPECT_CALL(network_config_handler_,
               SetPolicy(CurrentONCSource(),
                         ExpectedUsernameHash(),
                         IsEqualTo(&fake_network_configs_),
                         IsEqualTo(&fake_global_network_config_)));
   certificate_importer_->SetExpectedONCCertificates(fake_certificates_);
   certificate_importer_->SetExpectedONCSource(CurrentONCSource());
 
   CreateNetworkConfigurationUpdater();
   MarkPolicyProviderInitialized();
   EXPECT_EQ(ExpectedImportCertificatesCallCount(),
             certificate_importer_->GetAndResetImportCount());
 }
 
 TEST_P(NetworkConfigurationUpdaterTestWithParam,
        PolicyNotSetBeforePolicyProviderInitialized) {
   PolicyMap policy;
   policy.Set(GetParam(), POLICY_LEVEL_MANDATORY, POLICY_SCOPE_USER,
-             POLICY_SOURCE_CLOUD, new base::StringValue(kFakeONC), nullptr);
+             POLICY_SOURCE_CLOUD,
+             base::WrapUnique(new base::StringValue(kFakeONC)), nullptr);
   UpdateProviderPolicy(policy);
 
   CreateNetworkConfigurationUpdater();
 
   Mock::VerifyAndClearExpectations(&network_config_handler_);
   EXPECT_EQ(0u, certificate_importer_->GetAndResetImportCount());
 
   EXPECT_CALL(network_config_handler_,
               SetPolicy(CurrentONCSource(),
                         ExpectedUsernameHash(),
                         IsEqualTo(&fake_network_configs_),
                         IsEqualTo(&fake_global_network_config_)));
   certificate_importer_->SetExpectedONCSource(CurrentONCSource());
   certificate_importer_->SetExpectedONCCertificates(fake_certificates_);
 
   MarkPolicyProviderInitialized();
   EXPECT_EQ(ExpectedImportCertificatesCallCount(),
             certificate_importer_->GetAndResetImportCount());
 }
 
 TEST_P(NetworkConfigurationUpdaterTestWithParam,
        PolicyAppliedImmediatelyIfProvidersInitialized) {
   MarkPolicyProviderInitialized();
 
   PolicyMap policy;
   policy.Set(GetParam(), POLICY_LEVEL_MANDATORY, POLICY_SCOPE_USER,
-             POLICY_SOURCE_CLOUD, new base::StringValue(kFakeONC), nullptr);
+             POLICY_SOURCE_CLOUD,
+             base::WrapUnique(new base::StringValue(kFakeONC)), nullptr);
   UpdateProviderPolicy(policy);
 
   EXPECT_CALL(network_config_handler_,
               SetPolicy(CurrentONCSource(),
                         ExpectedUsernameHash(),
                         IsEqualTo(&fake_network_configs_),
                         IsEqualTo(&fake_global_network_config_)));
   certificate_importer_->SetExpectedONCSource(CurrentONCSource());
   certificate_importer_->SetExpectedONCCertificates(fake_certificates_);
 
@@ skipping 18 matching lines @@
   EXPECT_CALL(network_config_handler_,
               SetPolicy(CurrentONCSource(),
                         _,
                         IsEqualTo(&fake_network_configs_),
                         IsEqualTo(&fake_global_network_config_)));
   certificate_importer_->SetExpectedONCSource(CurrentONCSource());
   certificate_importer_->SetExpectedONCCertificates(fake_certificates_);
 
   PolicyMap policy;
   policy.Set(GetParam(), POLICY_LEVEL_MANDATORY, POLICY_SCOPE_USER,
-             POLICY_SOURCE_CLOUD, new base::StringValue(kFakeONC), nullptr);
+             POLICY_SOURCE_CLOUD,
+             base::WrapUnique(new base::StringValue(kFakeONC)), nullptr);
   UpdateProviderPolicy(policy);
   Mock::VerifyAndClearExpectations(&network_config_handler_);
   EXPECT_EQ(ExpectedImportCertificatesCallCount(),
             certificate_importer_->GetAndResetImportCount());
 
   // Another update is expected if the policy goes away.
   EXPECT_CALL(network_config_handler_,
               SetPolicy(CurrentONCSource(), _, IsEmpty(), IsEmpty()));
   certificate_importer_->SetExpectedONCCertificates(base::ListValue());
 
   policy.Erase(GetParam());
   UpdateProviderPolicy(policy);
   EXPECT_EQ(ExpectedImportCertificatesCallCount(),
             certificate_importer_->GetAndResetImportCount());
 }
 
 INSTANTIATE_TEST_CASE_P(NetworkConfigurationUpdaterTestWithParamInstance,
                         NetworkConfigurationUpdaterTestWithParam,
                         testing::Values(key::kDeviceOpenNetworkConfiguration,
                                         key::kOpenNetworkConfiguration));
 
 }  // namespace policy