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

chrome/browser/extensions/api/enterprise_platform_keys/enterprise_platform_keys_api_unittest.cc

 // Copyright (c) 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/extensions/api/enterprise_platform_keys/enterprise_platform_keys_api.h"
 
 #include <string>
 
 #include "base/bind.h"
 #include "base/location.h"
@@ skipping 190 matching lines @@
   // Derived classes can override this method to set the required authenticated
   // user in the SigninManager class.
   virtual void SetAuthenticatedUser() {
     SigninManagerFactory::GetForProfile(browser()->profile())
         ->SetAuthenticatedAccountInfo("12345", kUserEmail);
   }
 
   // Like extension_function_test_utils::RunFunctionAndReturnError but with an
   // explicit ListValue.
   std::string RunFunctionAndReturnError(UIThreadExtensionFunction* function,
-                                        scoped_ptr<base::ListValue> args,
+                                        std::unique_ptr<base::ListValue> args,
                                         Browser* browser) {
     scoped_refptr<ExtensionFunction> function_owner(function);
     // Without a callback the function will not generate a result.
     function->set_has_callback(true);
     utils::RunFunction(function, std::move(args), browser, utils::NONE);
     EXPECT_FALSE(function->GetResultList()) << "Did not expect a result";
     return function->GetError();
   }
 
   // Like extension_function_test_utils::RunFunctionAndReturnSingleResult but
   // with an explicit ListValue.
   base::Value* RunFunctionAndReturnSingleResult(
       UIThreadExtensionFunction* function,
-      scoped_ptr<base::ListValue> args,
+      std::unique_ptr<base::ListValue> args,
       Browser* browser) {
     scoped_refptr<ExtensionFunction> function_owner(function);
     // Without a callback the function will not generate a result.
     function->set_has_callback(true);
     utils::RunFunction(function, std::move(args), browser, utils::NONE);
     EXPECT_TRUE(function->GetError().empty()) << "Unexpected error: "
                                               << function->GetError();
     const base::Value* single_result = NULL;
     if (function->GetResultList() != NULL &&
         function->GetResultList()->Get(0, &single_result)) {
@@ skipping 25 matching lines @@
         func_(new EnterprisePlatformKeysChallengeMachineKeyFunction(&impl_)) {
     func_->set_extension(extension_.get());
   }
 
   // Returns an error string for the given code.
   std::string GetCertificateError(int error_code) {
     return base::StringPrintf(
         EPKPChallengeMachineKey::kGetCertificateFailedError, error_code);
   }
 
-  scoped_ptr<base::ListValue> CreateArgs() {
-    scoped_ptr<base::ListValue> args(new base::ListValue);
+  std::unique_ptr<base::ListValue> CreateArgs() {
+    std::unique_ptr<base::ListValue> args(new base::ListValue);
     args->Append(base::BinaryValue::CreateWithCopiedBuffer("challenge", 9));
     return args;
   }
 
   EPKPChallengeMachineKey impl_;
   scoped_refptr<EnterprisePlatformKeysChallengeMachineKeyFunction> func_;
   base::ListValue args_;
 };
 
 TEST_F(EPKChallengeMachineKeyTest, NonEnterpriseDevice) {
@@ skipping 63 matching lines @@
                   _, _, _, _))
       .Times(1);
   // SignEnterpriseChallenge must be called exactly once.
   EXPECT_CALL(
       mock_async_method_caller_,
       TpmAttestationSignEnterpriseChallenge(
           chromeos::attestation::KEY_DEVICE, cryptohome::Identification(),
           "attest-ent-machine", "google.com", "device_id", _, "challenge", _))
       .Times(1);
 
-  scoped_ptr<base::Value> value(
+  std::unique_ptr<base::Value> value(
       RunFunctionAndReturnSingleResult(func_.get(), CreateArgs(), browser()));
 
   const base::BinaryValue* response;
   ASSERT_TRUE(value->GetAsBinary(&response));
   EXPECT_EQ("response",
             std::string(response->GetBuffer(), response->GetSize()));
 }
 
 TEST_F(EPKChallengeMachineKeyTest, AttestationNotPrepared) {
   EXPECT_CALL(mock_cryptohome_client_, TpmAttestationIsPrepared(_))
@@ skipping 30 matching lines @@
     // Set the user preferences.
     prefs_->SetBoolean(prefs::kAttestationEnabled, true);
   }
 
   // Returns an error string for the given code.
   std::string GetCertificateError(int error_code) {
     return base::StringPrintf(EPKPChallengeUserKey::kGetCertificateFailedError,
                               error_code);
   }
 
-  scoped_ptr<base::ListValue> CreateArgs() { return CreateArgsInternal(true); }
+  std::unique_ptr<base::ListValue> CreateArgs() {
+    return CreateArgsInternal(true);
+  }
 
-  scoped_ptr<base::ListValue> CreateArgsNoRegister() {
+  std::unique_ptr<base::ListValue> CreateArgsNoRegister() {
     return CreateArgsInternal(false);
   }
 
-  scoped_ptr<base::ListValue> CreateArgsInternal(bool register_key) {
-    scoped_ptr<base::ListValue> args(new base::ListValue);
+  std::unique_ptr<base::ListValue> CreateArgsInternal(bool register_key) {
+    std::unique_ptr<base::ListValue> args(new base::ListValue);
     args->Append(base::BinaryValue::CreateWithCopiedBuffer("challenge", 9));
     args->Append(new base::FundamentalValue(register_key));
     return args;
   }
 
   EPKPChallengeUserKey impl_;
   scoped_refptr<EnterprisePlatformKeysChallengeUserKeyFunction> func_;
 };
 
 TEST_F(EPKChallengeUserKeyTest, UserPolicyDisabled) {
@@ skipping 94 matching lines @@
       TpmAttestationSignEnterpriseChallenge(
           chromeos::attestation::KEY_USER, cryptohome_id, "attest-ent-user",
           kUserEmail, "device_id", _, "challenge", _))
       .Times(1);
   // RegisterKey must be called exactly once.
   EXPECT_CALL(mock_async_method_caller_,
               TpmAttestationRegisterKey(chromeos::attestation::KEY_USER,
                                         cryptohome_id, "attest-ent-user", _))
       .Times(1);
 
-  scoped_ptr<base::Value> value(
+  std::unique_ptr<base::Value> value(
       RunFunctionAndReturnSingleResult(func_.get(), CreateArgs(), browser()));
 
   const base::BinaryValue* response;
   ASSERT_TRUE(value->GetAsBinary(&response));
   EXPECT_EQ("response",
             std::string(response->GetBuffer(), response->GetSize()));
 }
 
 TEST_F(EPKChallengeUserKeyTest, AttestationNotPrepared) {
   EXPECT_CALL(mock_cryptohome_client_, TpmAttestationIsPrepared(_))
@@ skipping 57 matching lines @@
       AccountId::FromUserEmailGaiaId("test@chromium.com", "12345");
 };
 
 TEST_F(EPKChallengeUserKeyUnmanagedUserTest, UserNotManaged) {
   EXPECT_EQ(EPKPChallengeKeyBase::kUserNotManaged,
             RunFunctionAndReturnError(func_.get(), CreateArgs(), browser()));
 }
 
 }  // namespace
 }  // namespace extensions