Convert //remoting to use std::unique_ptr

remoting/protocol/negotiating_host_authenticator.cc

 // Copyright 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 "remoting/protocol/negotiating_host_authenticator.h"
 
 #include <algorithm>
 #include <sstream>
 #include <utility>
 
@@ skipping 18 matching lines @@
     const std::string& remote_id,
     const std::string& local_cert,
     scoped_refptr<RsaKeyPair> key_pair)
     : NegotiatingAuthenticatorBase(WAITING_MESSAGE),
       local_id_(local_id),
       remote_id_(remote_id),
       local_cert_(local_cert),
       local_key_pair_(key_pair) {}
 
 // static
-scoped_ptr<NegotiatingHostAuthenticator>
+std::unique_ptr<NegotiatingHostAuthenticator>
 NegotiatingHostAuthenticator::CreateWithSharedSecret(
     const std::string& local_id,
     const std::string& remote_id,
     const std::string& local_cert,
     scoped_refptr<RsaKeyPair> key_pair,
     const std::string& shared_secret_hash,
     scoped_refptr<PairingRegistry> pairing_registry) {
-  scoped_ptr<NegotiatingHostAuthenticator> result(
+  std::unique_ptr<NegotiatingHostAuthenticator> result(
       new NegotiatingHostAuthenticator(local_id, remote_id, local_cert,
                                        key_pair));
   result->shared_secret_hash_ = shared_secret_hash;
   result->pairing_registry_ = pairing_registry;
   result->AddMethod(Method::SHARED_SECRET_SPAKE2_CURVE25519);
   result->AddMethod(Method::SHARED_SECRET_SPAKE2_P224);
   if (pairing_registry.get()) {
     result->AddMethod(Method::PAIRED_SPAKE2_CURVE25519);
     result->AddMethod(Method::PAIRED_SPAKE2_P224);
   }
   return result;
 }
 
 // static
-scoped_ptr<NegotiatingHostAuthenticator>
+std::unique_ptr<NegotiatingHostAuthenticator>
 NegotiatingHostAuthenticator::CreateWithThirdPartyAuth(
     const std::string& local_id,
     const std::string& remote_id,
     const std::string& local_cert,
     scoped_refptr<RsaKeyPair> key_pair,
     scoped_refptr<TokenValidatorFactory> token_validator_factory) {
-  scoped_ptr<NegotiatingHostAuthenticator> result(
+  std::unique_ptr<NegotiatingHostAuthenticator> result(
       new NegotiatingHostAuthenticator(local_id, remote_id, local_cert,
                                        key_pair));
   result->token_validator_factory_ = token_validator_factory;
   result->AddMethod(Method::THIRD_PARTY_SPAKE2_CURVE25519);
   result->AddMethod(Method::THIRD_PARTY_SPAKE2_P224);
   return result;
 }
 
 NegotiatingHostAuthenticator::~NegotiatingHostAuthenticator() {}
 
@@ skipping 79 matching lines @@
                    base::Unretained(this),
                    base::Owned(new buzz::XmlElement(*message)),
                    resume_callback));
     return;
   }
 
   // If the client is using the host's current method, just process the message.
   ProcessMessageInternal(message, resume_callback);
 }
 
-scoped_ptr<buzz::XmlElement> NegotiatingHostAuthenticator::GetNextMessage() {
+std::unique_ptr<buzz::XmlElement>
+NegotiatingHostAuthenticator::GetNextMessage() {
   return GetNextMessageInternal();
 }
 
 void NegotiatingHostAuthenticator::CreateAuthenticator(
     Authenticator::State preferred_initial_state,
     const base::Closure& resume_callback) {
   DCHECK(current_method_ != Method::INVALID);
 
   switch(current_method_) {
     case Method::INVALID:
@@ skipping 54 matching lines @@
       current_authenticator_ = V2Authenticator::CreateForHost(
           local_cert_, local_key_pair_, shared_secret_hash_,
           preferred_initial_state);
       resume_callback.Run();
       break;
   }
 }
 
 }  // namespace protocol
 }  // namespace remoting