Convert //components/policy from scoped_ptr to std::unique_ptr

components/policy/core/common/policy_service_impl_unittest.cc

 // Copyright (c) 2012 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/policy_service_impl.h"
 
+#include <memory>
 #include <utility>
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/callback.h"
 #include "base/macros.h"
-#include "base/memory/scoped_ptr.h"
 #include "base/run_loop.h"
 #include "base/values.h"
 #include "components/policy/core/common/external_data_fetcher.h"
 #include "components/policy/core/common/mock_configuration_policy_provider.h"
 #include "components/policy/core/common/mock_policy_service.h"
 #include "components/policy/core/common/policy_types.h"
 #include "policy/policy_constants.h"
 #include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
@@ skipping 135 matching lines @@
   }
 
  protected:
   base::MessageLoop loop_;
   MockConfigurationPolicyProvider provider0_;
   MockConfigurationPolicyProvider provider1_;
   MockConfigurationPolicyProvider provider2_;
   PolicyMap policy0_;
   PolicyMap policy1_;
   PolicyMap policy2_;
-  scoped_ptr<PolicyServiceImpl> policy_service_;
+  std::unique_ptr<PolicyServiceImpl> policy_service_;
 
  private:
   DISALLOW_COPY_AND_ASSIGN(PolicyServiceTest);
 };
 
 TEST_F(PolicyServiceTest, LoadsPoliciesBeforeProvidersRefresh) {
   PolicyMap expected;
   expected.Set("pre",
                POLICY_LEVEL_MANDATORY,
                POLICY_SCOPE_USER,
@@ skipping 126 matching lines @@
                           NULL);
   PolicyMap policy_map;
   policy_map.CopyFrom(previous_policy_map);
   policy_map.Set("policy",
                  POLICY_LEVEL_MANDATORY,
                  POLICY_SCOPE_USER,
                  POLICY_SOURCE_CLOUD,
                  new base::StringValue("value"),
                  NULL);
 
-  scoped_ptr<PolicyBundle> bundle(new PolicyBundle());
+  std::unique_ptr<PolicyBundle> bundle(new PolicyBundle());
   // The initial setup includes a policy for chrome that is now changing.
   bundle->Get(PolicyNamespace(POLICY_DOMAIN_CHROME, std::string()))
       .CopyFrom(policy_map);
   bundle->Get(PolicyNamespace(POLICY_DOMAIN_EXTENSIONS, kExtension0))
       .CopyFrom(policy_map);
   bundle->Get(PolicyNamespace(POLICY_DOMAIN_EXTENSIONS, kExtension1))
       .CopyFrom(policy_map);
 
   const PolicyMap kEmptyPolicyMap;
   EXPECT_CALL(
@@ skipping 140 matching lines @@
                POLICY_SCOPE_USER,
                POLICY_SOURCE_CLOUD,
                new base::FundamentalValue(1),
                NULL);
   provider1_.UpdateChromePolicy(policy1_);
   EXPECT_TRUE(VerifyPolicies(
       PolicyNamespace(POLICY_DOMAIN_CHROME, std::string()), expected));
 }
 
 TEST_F(PolicyServiceTest, PolicyChangeRegistrar) {
-  scoped_ptr<PolicyChangeRegistrar> registrar(new PolicyChangeRegistrar(
+  std::unique_ptr<PolicyChangeRegistrar> registrar(new PolicyChangeRegistrar(
       policy_service_.get(),
       PolicyNamespace(POLICY_DOMAIN_CHROME, std::string())));
 
   // Starting to observe existing policies doesn't trigger a notification.
   EXPECT_CALL(*this, OnPolicyValueUpdated(_, _)).Times(0);
   registrar->Observe("pre", base::Bind(
       &PolicyServiceTest::OnPolicyValueUpdated,
       base::Unretained(this)));
   registrar->Observe("aaa", base::Bind(
       &PolicyServiceTest::OnPolicyValueUpdated,
@@ skipping 102 matching lines @@
   provider1_.UpdateChromePolicy(policy1_);
   Mock::VerifyAndClearExpectations(this);
 
   const PolicyMap& policies = policy_service_->GetPolicies(
       PolicyNamespace(POLICY_DOMAIN_CHROME, std::string()));
   EXPECT_TRUE(base::Value::Equals(&kValue2, policies.GetValue("aaa")));
   EXPECT_TRUE(base::Value::Equals(&kValue0, policies.GetValue("bbb")));
 }
 
 TEST_F(PolicyServiceTest, NamespaceMerge) {
-  scoped_ptr<PolicyBundle> bundle0(new PolicyBundle());
-  scoped_ptr<PolicyBundle> bundle1(new PolicyBundle());
-  scoped_ptr<PolicyBundle> bundle2(new PolicyBundle());
+  std::unique_ptr<PolicyBundle> bundle0(new PolicyBundle());
+  std::unique_ptr<PolicyBundle> bundle1(new PolicyBundle());
+  std::unique_ptr<PolicyBundle> bundle2(new PolicyBundle());
 
   AddTestPolicies(bundle0.get(), "bundle0",
                   POLICY_LEVEL_RECOMMENDED, POLICY_SCOPE_USER);
   AddTestPolicies(bundle1.get(), "bundle1",
                   POLICY_LEVEL_MANDATORY, POLICY_SCOPE_USER);
   AddTestPolicies(bundle2.get(), "bundle2",
                   POLICY_LEVEL_MANDATORY, POLICY_SCOPE_MACHINE);
 
   provider0_.UpdatePolicy(std::move(bundle0));
   provider1_.UpdatePolicy(std::move(bundle1));
@@ skipping 100 matching lines @@
 
   // Cleanup.
   policy_service_->RemoveObserver(POLICY_DOMAIN_CHROME, &observer);
   policy_service_->RemoveObserver(POLICY_DOMAIN_EXTENSIONS, &observer);
 }
 
 TEST_F(PolicyServiceTest, FixDeprecatedPolicies) {
   const PolicyNamespace chrome_namespace(POLICY_DOMAIN_CHROME, std::string());
   const PolicyNamespace extension_namespace(POLICY_DOMAIN_EXTENSIONS, "xyz");
 
-  scoped_ptr<PolicyBundle> policy_bundle(new PolicyBundle());
+  std::unique_ptr<PolicyBundle> policy_bundle(new PolicyBundle());
   PolicyMap& policy_map = policy_bundle->Get(chrome_namespace);
   // Individual proxy policy values in the Chrome namespace should be collected
   // into a dictionary.
   policy_map.Set(key::kProxyServerMode,
                  POLICY_LEVEL_MANDATORY,
                  POLICY_SCOPE_USER,
                  POLICY_SOURCE_CLOUD,
                  new base::FundamentalValue(3),
                  NULL);
 
@@ skipping 15 matching lines @@
   // Add a value to a non-Chrome namespace.
   policy_bundle->Get(extension_namespace).Set(key::kProxyServerMode,
                                               POLICY_LEVEL_MANDATORY,
                                               POLICY_SCOPE_USER,
                                               POLICY_SOURCE_CLOUD,
                                               new base::FundamentalValue(3),
                                               NULL);
 
   // The resulting Chrome namespace map should have the collected policy.
   PolicyMap expected_chrome;
-  scoped_ptr<base::DictionaryValue> expected_value(new base::DictionaryValue);
+  std::unique_ptr<base::DictionaryValue> expected_value(
+      new base::DictionaryValue);
   expected_value->SetInteger(key::kProxyServerMode, 3);
   expected_chrome.Set(key::kProxySettings, POLICY_LEVEL_MANDATORY,
                       POLICY_SCOPE_USER, POLICY_SOURCE_CLOUD,
                       expected_value.release(), nullptr);
 
   // The resulting Extensions namespace map shouldn't have been modified.
   PolicyMap expected_extension;
   expected_extension.Set(key::kProxyServerMode,
                          POLICY_LEVEL_MANDATORY,
                          POLICY_SCOPE_USER,
                          POLICY_SOURCE_CLOUD,
                          new base::FundamentalValue(3),
                          NULL);
 
   provider0_.UpdatePolicy(std::move(policy_bundle));
   RunUntilIdle();
 
   EXPECT_TRUE(VerifyPolicies(chrome_namespace, expected_chrome));
   EXPECT_TRUE(VerifyPolicies(extension_namespace, expected_extension));
 }
 
 }  // namespace policy