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

components/policy/core/common/cloud/policy_builder.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/cloud/policy_builder.h"
 
 #include <vector>
 
 #include "base/macros.h"
 #include "build/build_config.h"
@@ skipping 146 matching lines @@
   policy_data_->set_machine_name(kFakeMachineName);
   policy_data_->set_public_key_version(kFakePublicKeyVersion);
   policy_data_->set_username(kFakeUsername);
   policy_data_->set_device_id(kFakeDeviceId);
   policy_data_->set_state(em::PolicyData::ACTIVE);
   policy_data_->set_service_account_identity(kFakeServiceAccountIdentity);
 }
 
 PolicyBuilder::~PolicyBuilder() {}
 
-scoped_ptr<crypto::RSAPrivateKey> PolicyBuilder::GetSigningKey() {
+std::unique_ptr<crypto::RSAPrivateKey> PolicyBuilder::GetSigningKey() {
   if (raw_signing_key_.empty())
-    return scoped_ptr<crypto::RSAPrivateKey>();
-  return scoped_ptr<crypto::RSAPrivateKey>(
+    return std::unique_ptr<crypto::RSAPrivateKey>();
+  return std::unique_ptr<crypto::RSAPrivateKey>(
       crypto::RSAPrivateKey::CreateFromPrivateKeyInfo(raw_signing_key_));
 }
 
 void PolicyBuilder::SetSigningKey(const crypto::RSAPrivateKey& key) {
   key.ExportPrivateKey(&raw_signing_key_);
 }
 
 void PolicyBuilder::SetDefaultSigningKey() {
   std::vector<uint8_t> key(kSigningKey, kSigningKey + arraysize(kSigningKey));
   raw_signing_key_.swap(key);
 }
 
 void PolicyBuilder::UnsetSigningKey() {
   raw_signing_key_.clear();
 }
 
-scoped_ptr<crypto::RSAPrivateKey> PolicyBuilder::GetNewSigningKey() {
+std::unique_ptr<crypto::RSAPrivateKey> PolicyBuilder::GetNewSigningKey() {
   if (raw_new_signing_key_.empty())
-    return scoped_ptr<crypto::RSAPrivateKey>();
-  return scoped_ptr<crypto::RSAPrivateKey>(
+    return std::unique_ptr<crypto::RSAPrivateKey>();
+  return std::unique_ptr<crypto::RSAPrivateKey>(
       crypto::RSAPrivateKey::CreateFromPrivateKeyInfo(raw_new_signing_key_));
 }
 
 void PolicyBuilder::SetDefaultNewSigningKey() {
   std::vector<uint8_t> key(kNewSigningKey,
                            kNewSigningKey + arraysize(kNewSigningKey));
   raw_new_signing_key_.swap(key);
   raw_new_signing_key_signature_ = GetTestOtherSigningKeySignature();
 }
 
 void PolicyBuilder::SetDefaultInitialSigningKey() {
   std::vector<uint8_t> key(kSigningKey, kSigningKey + arraysize(kSigningKey));
   raw_new_signing_key_.swap(key);
   raw_new_signing_key_signature_ = GetTestSigningKeySignature();
   UnsetSigningKey();
 }
 
 void PolicyBuilder::UnsetNewSigningKey() {
   raw_new_signing_key_.clear();
   raw_new_signing_key_signature_.clear();
 }
 
 void PolicyBuilder::Build() {
   // Generate signatures if applicable.
-  scoped_ptr<crypto::RSAPrivateKey> policy_signing_key = GetNewSigningKey();
+  std::unique_ptr<crypto::RSAPrivateKey> policy_signing_key =
+      GetNewSigningKey();
   if (policy_signing_key) {
     // Add the new public key.
     std::vector<uint8_t> raw_new_public_signing_key;
     CHECK(policy_signing_key->ExportPublicKey(&raw_new_public_signing_key));
     policy_.set_new_public_key(raw_new_public_signing_key.data(),
                                raw_new_public_signing_key.size());
 
     policy_.set_new_public_key_verification_signature(
         raw_new_signing_key_signature_);
 
     // The new public key must be signed by the old key.
-    scoped_ptr<crypto::RSAPrivateKey> old_signing_key = GetSigningKey();
+    std::unique_ptr<crypto::RSAPrivateKey> old_signing_key = GetSigningKey();
     if (old_signing_key) {
       SignData(policy_.new_public_key(),
                old_signing_key.get(),
                policy_.mutable_new_public_key_signature());
     }
   } else {
     // No new signing key, so clear the old public key (this allows us to
     // reuse the same PolicyBuilder to build multiple policy blobs).
     policy_.clear_new_public_key();
     policy_.clear_new_public_key_signature();
@@ skipping 12 matching lines @@
   if (policy_signing_key) {
     SignData(policy_.policy_data(), policy_signing_key.get(),
              policy_.mutable_policy_data_signature());
   }
 }
 
 std::string PolicyBuilder::GetBlob() {
   return policy_.SerializeAsString();
 }
 
-scoped_ptr<em::PolicyFetchResponse> PolicyBuilder::GetCopy() {
-  scoped_ptr<em::PolicyFetchResponse> result(new em::PolicyFetchResponse());
+std::unique_ptr<em::PolicyFetchResponse> PolicyBuilder::GetCopy() {
+  std::unique_ptr<em::PolicyFetchResponse> result(
+      new em::PolicyFetchResponse());
   result->CopyFrom(policy_);
   return result;
 }
 
 // static
-scoped_ptr<crypto::RSAPrivateKey> PolicyBuilder::CreateTestSigningKey() {
+std::unique_ptr<crypto::RSAPrivateKey> PolicyBuilder::CreateTestSigningKey() {
   std::vector<uint8_t> raw_signing_key(kSigningKey,
                                        kSigningKey + arraysize(kSigningKey));
-  return scoped_ptr<crypto::RSAPrivateKey>(
+  return std::unique_ptr<crypto::RSAPrivateKey>(
       crypto::RSAPrivateKey::CreateFromPrivateKeyInfo(raw_signing_key));
 }
 
 // static
-scoped_ptr<crypto::RSAPrivateKey> PolicyBuilder::CreateTestOtherSigningKey() {
+std::unique_ptr<crypto::RSAPrivateKey>
+PolicyBuilder::CreateTestOtherSigningKey() {
   std::vector<uint8_t> raw_new_signing_key(
       kNewSigningKey, kNewSigningKey + arraysize(kNewSigningKey));
-  return scoped_ptr<crypto::RSAPrivateKey>(
+  return std::unique_ptr<crypto::RSAPrivateKey>(
       crypto::RSAPrivateKey::CreateFromPrivateKeyInfo(raw_new_signing_key));
 }
 
 // static
 std::string PolicyBuilder::GetTestSigningKeySignature() {
   return std::string(reinterpret_cast<const char*>(kSigningKeySignature),
                      sizeof(kSigningKeySignature));
 }
 
 // static
 std::string PolicyBuilder::GetTestOtherSigningKeySignature() {
   return std::string(reinterpret_cast<const char*>(kNewSigningKeySignature),
                      sizeof(kNewSigningKeySignature));
 }
 
 void PolicyBuilder::SignData(const std::string& data,
                              crypto::RSAPrivateKey* key,
                              std::string* signature) {
-  scoped_ptr<crypto::SignatureCreator> signature_creator(
-      crypto::SignatureCreator::Create(key,
-                                       crypto::SignatureCreator::SHA1));
+  std::unique_ptr<crypto::SignatureCreator> signature_creator(
+      crypto::SignatureCreator::Create(key, crypto::SignatureCreator::SHA1));
   signature_creator->Update(reinterpret_cast<const uint8_t*>(data.c_str()),
                             data.size());
   std::vector<uint8_t> signature_bytes;
   CHECK(signature_creator->Final(&signature_bytes));
   signature->assign(reinterpret_cast<const char*>(signature_bytes.data()),
                     signature_bytes.size());
 }
 
 template<>
 TypedPolicyBuilder<em::CloudPolicySettings>::TypedPolicyBuilder()
     : payload_(new em::CloudPolicySettings()) {
   policy_data().set_policy_type(dm_protocol::kChromeUserPolicyType);
 }
 
 // Have the instantiation compiled into the module.
 template class TypedPolicyBuilder<em::CloudPolicySettings>;
 
 #if !defined(OS_ANDROID) && !defined(OS_IOS)
 template<>
 TypedPolicyBuilder<em::ExternalPolicyData>::TypedPolicyBuilder()
     : payload_(new em::ExternalPolicyData()) {
   policy_data().set_policy_type(dm_protocol::kChromeExtensionPolicyType);
 }
 
 template class TypedPolicyBuilder<em::ExternalPolicyData>;
 #endif
 
 }  // namespace policy