Convert //components/[o-t]* from scoped_ptr to std::unique_ptr

components/ownership/owner_settings_service.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 "components/ownership/owner_settings_service.h"
 
 #include <cryptohi.h>
 #include <keyhi.h>
 #include <stdint.h>
 
 #include "base/bind.h"
 #include "base/callback.h"
 #include "base/location.h"
 #include "base/logging.h"
 #include "base/message_loop/message_loop.h"
 #include "base/task_runner.h"
 #include "base/task_runner_util.h"
 #include "base/values.h"
 #include "components/ownership/owner_key_util.h"
 #include "crypto/scoped_nss_types.h"
 
 namespace em = enterprise_management;
 
 namespace ownership {
 
 namespace {
 
-using ScopedSGNContext =
-    scoped_ptr<SGNContext,
-               crypto::NSSDestroyer1<SGNContext, SGN_DestroyContext, PR_TRUE>>;
+using ScopedSGNContext = std::unique_ptr<
+    SGNContext,
+    crypto::NSSDestroyer1<SGNContext, SGN_DestroyContext, PR_TRUE>>;
 
-scoped_ptr<em::PolicyFetchResponse> AssembleAndSignPolicy(
-    scoped_ptr<em::PolicyData> policy,
+std::unique_ptr<em::PolicyFetchResponse> AssembleAndSignPolicy(
+    std::unique_ptr<em::PolicyData> policy,
     SECKEYPrivateKey* private_key) {
   // Assemble the policy.
-  scoped_ptr<em::PolicyFetchResponse> policy_response(
+  std::unique_ptr<em::PolicyFetchResponse> policy_response(
       new em::PolicyFetchResponse());
   if (!policy->SerializeToString(policy_response->mutable_policy_data())) {
     LOG(ERROR) << "Failed to encode policy payload.";
-    return scoped_ptr<em::PolicyFetchResponse>(nullptr);
+    return nullptr;
   }
 
   ScopedSGNContext sign_context(
       SGN_NewContext(SEC_OID_PKCS1_SHA1_WITH_RSA_ENCRYPTION, private_key));
   if (!sign_context) {
     NOTREACHED();
     return nullptr;
   }
 
   SECItem signature_item;
@@ skipping 44 matching lines @@
   if (private_key_.get()) {
     base::MessageLoop::current()->PostTask(FROM_HERE,
                                            base::Bind(callback, IsOwner()));
   } else {
     pending_is_owner_callbacks_.push_back(callback);
   }
 }
 
 bool OwnerSettingsService::AssembleAndSignPolicyAsync(
     base::TaskRunner* task_runner,
-    scoped_ptr<em::PolicyData> policy,
+    std::unique_ptr<em::PolicyData> policy,
     const AssembleAndSignPolicyAsyncCallback& callback) {
   DCHECK(thread_checker_.CalledOnValidThread());
   if (!task_runner || !IsOwner())
     return false;
   return base::PostTaskAndReplyWithResult(
       task_runner,
       FROM_HERE,
       base::Bind(
           &AssembleAndSignPolicy, base::Passed(&policy), private_key_->key()),
       callback);
@@ skipping 43 matching lines @@
   for (std::vector<IsOwnerCallback>::iterator it(is_owner_callbacks.begin());
        it != is_owner_callbacks.end();
        ++it) {
     it->Run(is_owner);
   }
 
   OnPostKeypairLoadedActions();
 }
 
 }  // namespace ownership