Convert //chrome/browser/extensions from scoped_ptr to std::unique_ptr

chrome/browser/extensions/api/platform_keys/platform_keys_apitest_nss.cc

 // Copyright 2014 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 <cryptohi.h>
 
+#include <memory>
+
 #include "base/json/json_writer.h"
 #include "base/macros.h"
-#include "base/memory/scoped_ptr.h"
+#include "base/memory/ptr_util.h"
 #include "base/strings/stringprintf.h"
 #include "chrome/browser/chromeos/platform_keys/platform_keys_service.h"
 #include "chrome/browser/chromeos/platform_keys/platform_keys_service_factory.h"
 #include "chrome/browser/chromeos/policy/device_policy_cros_browser_test.h"
 #include "chrome/browser/chromeos/policy/user_policy_test_helper.h"
 #include "chrome/browser/extensions/extension_apitest.h"
 #include "chrome/browser/net/nss_context.h"
 #include "chrome/browser/policy/profile_policy_connector.h"
 #include "chrome/browser/policy/profile_policy_connector_factory.h"
 #include "chrome/browser/profiles/profile.h"
@@ skipping 163 matching lines @@
     policy_helper_->Init(
         base::DictionaryValue() /* empty mandatory policy */,
         base::DictionaryValue() /* empty recommended policy */);
   }
 
   void SetupKeyPermissionPolicy() {
     // Set up the test policy that gives |extension_| the permission to access
     // corporate keys.
     base::DictionaryValue key_permissions_policy;
     {
-      scoped_ptr<base::DictionaryValue> cert1_key_permission(
+      std::unique_ptr<base::DictionaryValue> cert1_key_permission(
           new base::DictionaryValue);
       cert1_key_permission->SetBooleanWithoutPathExpansion(
           "allowCorporateKeyUsage", true);
       key_permissions_policy.SetWithoutPathExpansion(
           extension_->id(), cert1_key_permission.release());
     }
 
     std::string key_permissions_policy_str;
     base::JSONWriter::WriteWithOptions(key_permissions_policy,
                                        base::JSONWriter::OPTIONS_PRETTY_PRINT,
                                        &key_permissions_policy_str);
 
     base::DictionaryValue user_policy;
     user_policy.SetStringWithoutPathExpansion(policy::key::kKeyPermissions,
                                               key_permissions_policy_str);
 
     policy_helper_->UpdatePolicy(
         user_policy, base::DictionaryValue() /* empty recommended policy */,
         browser()->profile());
   }
 
   void GotPermissionsForExtension(
       const base::Closure& done_callback,
-      scoped_ptr<chromeos::KeyPermissions::PermissionsForExtension>
+      std::unique_ptr<chromeos::KeyPermissions::PermissionsForExtension>
           permissions_for_ext) {
     std::string client_cert1_spki =
         chromeos::platform_keys::GetSubjectPublicKeyInfo(client_cert1_);
     permissions_for_ext->RegisterKeyForCorporateUsage(client_cert1_spki);
     done_callback.Run();
   }
 
   void SetupTestCerts(const base::Closure& done_callback,
                       net::NSSCertDatabase* cert_db) {
     SetupTestClientCerts(cert_db);
@@ skipping 36 matching lines @@
 
   void TearDownTestSystemSlotOnIO(const base::Closure& done_callback) {
     DCHECK_CURRENTLY_ON(content::BrowserThread::IO);
     test_system_slot_.reset();
 
     content::BrowserThread::PostTask(content::BrowserThread::UI, FROM_HERE,
                                      done_callback);
   }
 
   const bool key_permission_policy_;
-  scoped_ptr<policy::UserPolicyTestHelper> policy_helper_;
+  std::unique_ptr<policy::UserPolicyTestHelper> policy_helper_;
   policy::DevicePolicyCrosTestHelper device_policy_test_helper_;
-  scoped_ptr<crypto::ScopedTestSystemNSSKeySlot> test_system_slot_;
+  std::unique_ptr<crypto::ScopedTestSystemNSSKeySlot> test_system_slot_;
 };
 
 class TestSelectDelegate
     : public chromeos::PlatformKeysService::SelectDelegate {
  public:
   // On each Select call, selects the next entry in |certs_to_select| from back
   // to front. Once the first entry is reached, that one will be selected
   // repeatedly.
   // Entries of |certs_to_select| can be null in which case no certificate will
   // be selected.
@@ skipping 73 matching lines @@
 // permissions and afterwards runs more basic tests.
 // After the initial two interactive calls, the simulated user does not select
 // any cert.
 IN_PROC_BROWSER_TEST_P(UnmanagedPlatformKeysTest, Basic) {
   net::CertificateList certs;
   certs.push_back(nullptr);
   certs.push_back(client_cert2_);
   certs.push_back(client_cert1_);
 
   GetPlatformKeysService()->SetSelectDelegate(
-      make_scoped_ptr(new TestSelectDelegate(certs)));
+      base::WrapUnique(new TestSelectDelegate(certs)));
 
   ASSERT_TRUE(RunExtensionTest("basicTests")) << message_;
 }
 
 // On interactive calls, the simulated user always selects |client_cert1_| if
 // matching.
 IN_PROC_BROWSER_TEST_P(UnmanagedPlatformKeysTest, Permissions) {
   net::CertificateList certs;
   certs.push_back(client_cert1_);
 
   GetPlatformKeysService()->SetSelectDelegate(
-      make_scoped_ptr(new TestSelectDelegate(certs)));
+      base::WrapUnique(new TestSelectDelegate(certs)));
 
   ASSERT_TRUE(RunExtensionTest("permissionTests")) << message_;
 }
 
 INSTANTIATE_TEST_CASE_P(Unmanaged,
                         UnmanagedPlatformKeysTest,
                         ::testing::Values(DEVICE_STATUS_ENROLLED,
                                           DEVICE_STATUS_NOT_ENROLLED));
 
 IN_PROC_BROWSER_TEST_P(ManagedWithoutPermissionPlatformKeysTest,
                        UserPermissionsBlocked) {
   // To verify that the user is not prompted for any certificate selection,
   // set up a delegate that fails on any invocation.
   GetPlatformKeysService()->SetSelectDelegate(
-      make_scoped_ptr(new TestSelectDelegate(net::CertificateList())));
+      base::WrapUnique(new TestSelectDelegate(net::CertificateList())));
 
   ASSERT_TRUE(RunExtensionTest("managedProfile")) << message_;
 }
 
 // A corporate key must not be useable if there is no policy permitting it.
 IN_PROC_BROWSER_TEST_P(ManagedWithoutPermissionPlatformKeysTest,
                        CorporateKeyAccessBlocked) {
   RegisterClient1AsCorporateKey();
 
   // To verify that the user is not prompted for any certificate selection,
   // set up a delegate that fails on any invocation.
   GetPlatformKeysService()->SetSelectDelegate(
-      make_scoped_ptr(new TestSelectDelegate(net::CertificateList())));
+      base::WrapUnique(new TestSelectDelegate(net::CertificateList())));
 
   ASSERT_TRUE(RunExtensionTest("corporateKeyWithoutPermissionTests"))
       << message_;
 }
 
 INSTANTIATE_TEST_CASE_P(
     ManagedWithoutPermission,
     ManagedWithoutPermissionPlatformKeysTest,
     ::testing::Values(
         Params(DEVICE_STATUS_ENROLLED, USER_STATUS_MANAGED_AFFILIATED_DOMAIN),
         Params(DEVICE_STATUS_ENROLLED, USER_STATUS_MANAGED_OTHER_DOMAIN),
         Params(DEVICE_STATUS_NOT_ENROLLED, USER_STATUS_MANAGED_OTHER_DOMAIN)));
 
 IN_PROC_BROWSER_TEST_P(ManagedWithPermissionPlatformKeysTest,
                        PolicyGrantsAccessToCorporateKey) {
   RegisterClient1AsCorporateKey();
 
   // Set up the test SelectDelegate to select |client_cert1_| if available for
   // selection.
   net::CertificateList certs;
   certs.push_back(client_cert1_);
 
   GetPlatformKeysService()->SetSelectDelegate(
-      make_scoped_ptr(new TestSelectDelegate(certs)));
+      base::WrapUnique(new TestSelectDelegate(certs)));
 
   ASSERT_TRUE(RunExtensionTest("corporateKeyWithPermissionTests")) << message_;
 }
 
 IN_PROC_BROWSER_TEST_P(ManagedWithPermissionPlatformKeysTest,
                        PolicyDoesGrantAccessToNonCorporateKey) {
   // The policy grants access to corporate keys but none are available.
   // As the profile is managed, the user must not be able to grant any
   // certificate permission. Set up a delegate that fails on any invocation.
   GetPlatformKeysService()->SetSelectDelegate(
-      make_scoped_ptr(new TestSelectDelegate(net::CertificateList())));
+      base::WrapUnique(new TestSelectDelegate(net::CertificateList())));
 
   ASSERT_TRUE(RunExtensionTest("policyDoesGrantAccessToNonCorporateKey"))
       << message_;
 }
 
 INSTANTIATE_TEST_CASE_P(
     ManagedWithPermission,
     ManagedWithPermissionPlatformKeysTest,
     ::testing::Values(
         Params(DEVICE_STATUS_ENROLLED, USER_STATUS_MANAGED_AFFILIATED_DOMAIN),
         Params(DEVICE_STATUS_ENROLLED, USER_STATUS_MANAGED_OTHER_DOMAIN),
         Params(DEVICE_STATUS_NOT_ENROLLED, USER_STATUS_MANAGED_OTHER_DOMAIN)));