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

chrome/browser/extensions/api/easy_unlock_private/easy_unlock_private_api_chromeos_unittest.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 "chrome/browser/extensions/api/easy_unlock_private/easy_unlock_private_api.h"
 
+#include <memory>
 #include <string>
 #include <utility>
 
 #include "base/bind.h"
 #include "base/command_line.h"
 #include "base/macros.h"
-#include "base/memory/scoped_ptr.h"
+#include "base/memory/ptr_util.h"
 #include "base/strings/stringprintf.h"
 #include "base/thread_task_runner_handle.h"
 #include "base/values.h"
 #include "chrome/browser/extensions/extension_api_unittest.h"
 #include "chrome/browser/extensions/extension_function_test_utils.h"
 #include "chrome/browser/extensions/extension_system_factory.h"
 #include "chrome/browser/extensions/test_extension_prefs.h"
 #include "chrome/browser/extensions/test_extension_system.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/browser/signin/easy_unlock_app_manager.h"
@@ skipping 197 matching lines @@
   client_->GenerateEcP256KeyPair(
       base::Bind(&CopyKeyPair, &private_key_2_unused, &public_key_2));
 
   std::string expected_result;
   client_->PerformECDHKeyAgreement(
       private_key_1,
       public_key_2,
       base::Bind(&CopyData, &expected_result));
   ASSERT_GT(expected_result.length(), 0u);
 
-  scoped_ptr<base::ListValue> args(new base::ListValue);
+  std::unique_ptr<base::ListValue> args(new base::ListValue);
   args->Append(StringToBinaryValue(private_key_1));
   args->Append(StringToBinaryValue(public_key_2));
 
   ASSERT_TRUE(extension_function_test_utils::RunFunction(
       function.get(), std::move(args), browser(),
       extension_function_test_utils::NONE));
 
   EXPECT_EQ(expected_result, GetSingleBinaryResultAsString(function.get()));
 }
 
@@ skipping 11 matching lines @@
   create_options.encryption_type = easy_unlock::kEncryptionTypeAES256CBC;
   create_options.signature_type = easy_unlock::kSignatureTypeHMACSHA256;
 
   std::string expected_result;
   client_->CreateSecureMessage(
       "PAYLOAD",
       create_options,
       base::Bind(&CopyData, &expected_result));
   ASSERT_GT(expected_result.length(), 0u);
 
-  scoped_ptr<base::ListValue> args(new base::ListValue);
+  std::unique_ptr<base::ListValue> args(new base::ListValue);
   args->Append(StringToBinaryValue("PAYLOAD"));
   args->Append(StringToBinaryValue("KEY"));
   base::DictionaryValue* options = new base::DictionaryValue();
   args->Append(options);
   options->Set("associatedData", StringToBinaryValue("ASSOCIATED_DATA"));
   options->Set("publicMetadata", StringToBinaryValue("PUBLIC_METADATA"));
   options->Set("verificationKeyId",
                StringToBinaryValue("VERIFICATION_KEY_ID"));
   options->Set("decryptionKeyId",
                StringToBinaryValue("DECRYPTION_KEY_ID"));
@@ skipping 21 matching lines @@
   create_options.encryption_type = easy_unlock::kEncryptionTypeNone;
   create_options.signature_type = easy_unlock::kSignatureTypeHMACSHA256;
 
   std::string expected_result;
   client_->CreateSecureMessage(
       "PAYLOAD",
       create_options,
       base::Bind(&CopyData, &expected_result));
   ASSERT_GT(expected_result.length(), 0u);
 
-  scoped_ptr<base::ListValue> args(new base::ListValue);
+  std::unique_ptr<base::ListValue> args(new base::ListValue);
   args->Append(StringToBinaryValue("PAYLOAD"));
   args->Append(StringToBinaryValue("KEY"));
   base::DictionaryValue* options = new base::DictionaryValue();
   args->Append(options);
 
   ASSERT_TRUE(extension_function_test_utils::RunFunction(
       function.get(), std::move(args), browser(),
       extension_function_test_utils::NONE));
 
   EXPECT_EQ(expected_result, GetSingleBinaryResultAsString(function.get()));
@@ skipping 11 matching lines @@
   create_options.encryption_type = easy_unlock::kEncryptionTypeNone;
   create_options.signature_type = easy_unlock::kSignatureTypeECDSAP256SHA256;
 
   std::string expected_result;
   client_->CreateSecureMessage(
       "PAYLOAD",
       create_options,
       base::Bind(&CopyData, &expected_result));
   ASSERT_GT(expected_result.length(), 0u);
 
-  scoped_ptr<base::ListValue> args(new base::ListValue);
+  std::unique_ptr<base::ListValue> args(new base::ListValue);
   args->Append(StringToBinaryValue("PAYLOAD"));
   args->Append(StringToBinaryValue("KEY"));
   base::DictionaryValue* options = new base::DictionaryValue();
   args->Append(options);
   options->Set("associatedData",
                StringToBinaryValue("ASSOCIATED_DATA"));
   options->Set("verificationKeyId",
                StringToBinaryValue("VERIFICATION_KEY_ID"));
   options->SetString(
       "signType",
@@ skipping 17 matching lines @@
   unwrap_options.encryption_type = easy_unlock::kEncryptionTypeAES256CBC;
   unwrap_options.signature_type = easy_unlock::kSignatureTypeHMACSHA256;
 
   std::string expected_result;
   client_->UnwrapSecureMessage(
       "MESSAGE",
       unwrap_options,
       base::Bind(&CopyData, &expected_result));
   ASSERT_GT(expected_result.length(), 0u);
 
-  scoped_ptr<base::ListValue> args(new base::ListValue);
+  std::unique_ptr<base::ListValue> args(new base::ListValue);
   args->Append(StringToBinaryValue("MESSAGE"));
   args->Append(StringToBinaryValue("KEY"));
   base::DictionaryValue* options = new base::DictionaryValue();
   args->Append(options);
   options->Set("associatedData", StringToBinaryValue("ASSOCIATED_DATA"));
   options->SetString(
       "encryptType",
       api::ToString(api::ENCRYPTION_TYPE_AES_256_CBC));
   options->SetString(
       "signType",
@@ skipping 16 matching lines @@
   unwrap_options.encryption_type = easy_unlock::kEncryptionTypeNone;
   unwrap_options.signature_type = easy_unlock::kSignatureTypeHMACSHA256;
 
   std::string expected_result;
   client_->UnwrapSecureMessage(
       "MESSAGE",
       unwrap_options,
       base::Bind(&CopyData, &expected_result));
   ASSERT_GT(expected_result.length(), 0u);
 
-  scoped_ptr<base::ListValue> args(new base::ListValue);
+  std::unique_ptr<base::ListValue> args(new base::ListValue);
   args->Append(StringToBinaryValue("MESSAGE"));
   args->Append(StringToBinaryValue("KEY"));
   base::DictionaryValue* options = new base::DictionaryValue();
   args->Append(options);
 
   ASSERT_TRUE(extension_function_test_utils::RunFunction(
       function.get(), std::move(args), browser(),
       extension_function_test_utils::NONE));
 
   EXPECT_EQ(expected_result, GetSingleBinaryResultAsString(function.get()));
@@ skipping 10 matching lines @@
   unwrap_options.encryption_type = easy_unlock::kEncryptionTypeNone;
   unwrap_options.signature_type = easy_unlock::kSignatureTypeECDSAP256SHA256;
 
   std::string expected_result;
   client_->UnwrapSecureMessage(
       "MESSAGE",
       unwrap_options,
       base::Bind(&CopyData, &expected_result));
   ASSERT_GT(expected_result.length(), 0u);
 
-  scoped_ptr<base::ListValue> args(new base::ListValue);
+  std::unique_ptr<base::ListValue> args(new base::ListValue);
   args->Append(StringToBinaryValue("MESSAGE"));
   args->Append(StringToBinaryValue("KEY"));
   base::DictionaryValue* options = new base::DictionaryValue();
   args->Append(options);
   options->Set("associatedData",
                StringToBinaryValue("ASSOCIATED_DATA"));
   options->SetString(
       "signType",
       api::ToString(api::SIGNATURE_TYPE_ECDSA_P256_SHA256));
 
@@ skipping 10 matching lines @@
   void SetResult(bool success, const std::string& error) {
     this->success = success;
     this->error = error;
   }
 
   bool success;
   std::string error;
 };
 
 // Test factory to register EasyUnlockService.
-scoped_ptr<KeyedService> BuildTestEasyUnlockService(
+std::unique_ptr<KeyedService> BuildTestEasyUnlockService(
     content::BrowserContext* context) {
-  scoped_ptr<EasyUnlockServiceRegular> service(
+  std::unique_ptr<EasyUnlockServiceRegular> service(
       new EasyUnlockServiceRegular(Profile::FromBrowserContext(context)));
   service->Initialize(
       EasyUnlockAppManager::Create(extensions::ExtensionSystem::Get(context),
                                    -1 /* manifest id */, base::FilePath()));
   return std::move(service);
 }
 
 // A fake EventRouter that logs event it dispatches for testing.
 class FakeEventRouter : public extensions::EventRouter {
  public:
-  FakeEventRouter(Profile* profile,
-                  scoped_ptr<extensions::TestExtensionPrefs> extension_prefs)
+  FakeEventRouter(
+      Profile* profile,
+      std::unique_ptr<extensions::TestExtensionPrefs> extension_prefs)
       : EventRouter(profile, extension_prefs->prefs()),
         extension_prefs_(std::move(extension_prefs)),
         event_count_(0) {}
 
-  void DispatchEventToExtension(const std::string& extension_id,
-                                scoped_ptr<extensions::Event> event) override {
+  void DispatchEventToExtension(
+      const std::string& extension_id,
+      std::unique_ptr<extensions::Event> event) override {
     ++event_count_;
     last_extension_id_ = extension_id;
     last_event_name_ = event ? event->event_name : std::string();
   }
 
   int event_count() const { return event_count_; }
   const std::string& last_extension_id() const { return last_extension_id_; }
   const std::string& last_event_name() const { return last_event_name_; }
 
  private:
-  scoped_ptr<extensions::TestExtensionPrefs> extension_prefs_;
+  std::unique_ptr<extensions::TestExtensionPrefs> extension_prefs_;
   int event_count_;
   std::string last_extension_id_;
   std::string last_event_name_;
 };
 
 // FakeEventRouter factory function
-scoped_ptr<KeyedService> FakeEventRouterFactoryFunction(
+std::unique_ptr<KeyedService> FakeEventRouterFactoryFunction(
     content::BrowserContext* profile) {
-  scoped_ptr<extensions::TestExtensionPrefs> extension_prefs(
+  std::unique_ptr<extensions::TestExtensionPrefs> extension_prefs(
       new extensions::TestExtensionPrefs(base::ThreadTaskRunnerHandle::Get()));
-  return make_scoped_ptr(new FakeEventRouter(static_cast<Profile*>(profile),
-                                             std::move(extension_prefs)));
+  return base::WrapUnique(new FakeEventRouter(static_cast<Profile*>(profile),
+                                              std::move(extension_prefs)));
 }
 
 TEST_F(EasyUnlockPrivateApiTest, AutoPairing) {
   FakeEventRouter* event_router = static_cast<FakeEventRouter*>(
       extensions::EventRouterFactory::GetInstance()->SetTestingFactoryAndUse(
           profile(), &FakeEventRouterFactoryFunction));
 
   EasyUnlockServiceFactory::GetInstance()->SetTestingFactoryAndUse(
       profile(), &BuildTestEasyUnlockService);
 
@@ skipping 38 matching lines @@
 // natively synced devices if the kEnableBluetoothLowEnergyDiscovery switch is
 // set.
 TEST_F(EasyUnlockPrivateApiTest, GetRemoteDevicesExperimental) {
   base::CommandLine::ForCurrentProcess()->AppendSwitch(
       proximity_auth::switches::kEnableBluetoothLowEnergyDiscovery);
   EasyUnlockServiceFactory::GetInstance()->SetTestingFactoryAndUse(
       profile(), &BuildTestEasyUnlockService);
 
   scoped_refptr<TestableGetRemoteDevicesFunction> function(
       new TestableGetRemoteDevicesFunction());
-  scoped_ptr<base::Value> value(
+  std::unique_ptr<base::Value> value(
       extensions::api_test_utils::RunFunctionAndReturnSingleResult(
           function.get(), "[]", profile()));
   ASSERT_TRUE(value.get());
   ASSERT_EQ(base::Value::TYPE_LIST, value->GetType());
 
   base::ListValue* list_value = static_cast<base::ListValue*>(value.get());
   EXPECT_EQ(2u, list_value->GetSize());
 
   base::Value* remote_device1;
   base::Value* remote_device2;
@@ skipping 13 matching lines @@
 }
 
 // Checks that the chrome.easyUnlockPrivate.getRemoteDevices API returns the
 // stored value if the kEnableBluetoothLowEnergyDiscovery switch is not set.
 TEST_F(EasyUnlockPrivateApiTest, GetRemoteDevicesNonExperimental) {
   EasyUnlockServiceFactory::GetInstance()->SetTestingFactoryAndUse(
       profile(), &BuildTestEasyUnlockService);
 
   scoped_refptr<TestableGetRemoteDevicesFunction> function(
       new TestableGetRemoteDevicesFunction());
-  scoped_ptr<base::Value> value(
+  std::unique_ptr<base::Value> value(
       extensions::api_test_utils::RunFunctionAndReturnSingleResult(
           function.get(), "[]", profile()));
   ASSERT_TRUE(value.get());
   ASSERT_EQ(base::Value::TYPE_LIST, value->GetType());
 
   base::ListValue* list_value = static_cast<base::ListValue*>(value.get());
   EXPECT_EQ(0u, list_value->GetSize());
 }
 
 // Checks that the chrome.easyUnlockPrivate.getPermitAccess API returns the
 // native permit access if the kEnableBluetoothLowEnergyDiscovery switch is
 // set.
 TEST_F(EasyUnlockPrivateApiTest, GetPermitAccessExperimental) {
   base::CommandLine::ForCurrentProcess()->AppendSwitch(
       proximity_auth::switches::kEnableBluetoothLowEnergyDiscovery);
   EasyUnlockServiceFactory::GetInstance()->SetTestingFactoryAndUse(
       profile(), &BuildTestEasyUnlockService);
 
   scoped_refptr<TestableGetPermitAccessFunction> function(
       new TestableGetPermitAccessFunction());
-  scoped_ptr<base::Value> value(
+  std::unique_ptr<base::Value> value(
       extensions::api_test_utils::RunFunctionAndReturnSingleResult(
           function.get(), "[]", profile()));
   ASSERT_TRUE(value);
   ASSERT_EQ(base::Value::TYPE_DICTIONARY, value->GetType());
   base::DictionaryValue* permit_access =
       static_cast<base::DictionaryValue*>(value.get());
 
   std::string user_public_key, user_private_key;
   EXPECT_TRUE(permit_access->GetString("id", &user_public_key));
   EXPECT_TRUE(permit_access->GetString("data", &user_private_key));
   EXPECT_EQ("user public key", user_public_key);
   EXPECT_EQ("user private key", user_private_key);
 }
 
 // Checks that the chrome.easyUnlockPrivate.getPermitAccess API returns the
 // stored value if the kEnableBluetoothLowEnergyDiscovery switch is not set.
 TEST_F(EasyUnlockPrivateApiTest, GetPermitAccessNonExperimental) {
   EasyUnlockServiceFactory::GetInstance()->SetTestingFactoryAndUse(
       profile(), &BuildTestEasyUnlockService);
 
   scoped_refptr<TestableGetPermitAccessFunction> function(
       new TestableGetPermitAccessFunction());
-  scoped_ptr<base::Value> value(
+  std::unique_ptr<base::Value> value(
       extensions::api_test_utils::RunFunctionAndReturnSingleResult(
           function.get(), "[]", profile()));
   EXPECT_FALSE(value);
 }
 
 }  // namespace