Convert //remoting to use std::unique_ptr

remoting/protocol/v2_authenticator.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 "remoting/protocol/v2_authenticator.h"
 
 #include <utility>
 
 #include "base/base64.h"
 #include "base/logging.h"
+#include "base/memory/ptr_util.h"
 #include "remoting/base/constants.h"
 #include "remoting/base/rsa_key_pair.h"
 #include "remoting/protocol/ssl_hmac_channel_authenticator.h"
 #include "third_party/webrtc/libjingle/xmllite/xmlelement.h"
 
 using crypto::P224EncryptedKeyExchange;
 
 namespace remoting {
 namespace protocol {
 
 namespace {
 
 const buzz::StaticQName kEkeTag = { kChromotingXmlNamespace,
                                     "eke-message" };
 const buzz::StaticQName kCertificateTag = { kChromotingXmlNamespace,
                                             "certificate" };
 
 }  // namespace
 
 // static
 bool V2Authenticator::IsEkeMessage(const buzz::XmlElement* message) {
   return message->FirstNamed(kEkeTag) != nullptr;
 }
 
 // static
-scoped_ptr<Authenticator> V2Authenticator::CreateForClient(
+std::unique_ptr<Authenticator> V2Authenticator::CreateForClient(
     const std::string& shared_secret,
     Authenticator::State initial_state) {
-  return make_scoped_ptr(new V2Authenticator(
+  return base::WrapUnique(new V2Authenticator(
       P224EncryptedKeyExchange::kPeerTypeClient, shared_secret, initial_state));
 }
 
 // static
-scoped_ptr<Authenticator> V2Authenticator::CreateForHost(
+std::unique_ptr<Authenticator> V2Authenticator::CreateForHost(
     const std::string& local_cert,
     scoped_refptr<RsaKeyPair> key_pair,
     const std::string& shared_secret,
     Authenticator::State initial_state) {
-  scoped_ptr<V2Authenticator> result(new V2Authenticator(
+  std::unique_ptr<V2Authenticator> result(new V2Authenticator(
       P224EncryptedKeyExchange::kPeerTypeServer, shared_secret, initial_state));
   result->local_cert_ = local_cert;
   result->local_key_pair_ = key_pair;
   return std::move(result);
 }
 
 V2Authenticator::V2Authenticator(
     crypto::P224EncryptedKeyExchange::PeerType type,
     const std::string& shared_secret,
     Authenticator::State initial_state)
@@ skipping 83 matching lines @@
 
       case P224EncryptedKeyExchange::kResultSuccess:
         auth_key_ = key_exchange_impl_.GetKey();
         state_ = ACCEPTED;
         return;
     }
   }
   state_ = MESSAGE_READY;
 }
 
-scoped_ptr<buzz::XmlElement> V2Authenticator::GetNextMessage() {
+std::unique_ptr<buzz::XmlElement> V2Authenticator::GetNextMessage() {
   DCHECK_EQ(state(), MESSAGE_READY);
 
-  scoped_ptr<buzz::XmlElement> message = CreateEmptyAuthenticatorMessage();
+  std::unique_ptr<buzz::XmlElement> message = CreateEmptyAuthenticatorMessage();
 
   DCHECK(!pending_messages_.empty());
   while (!pending_messages_.empty()) {
     const std::string& spake_message = pending_messages_.front();
     std::string base64_message;
     base::Base64Encode(spake_message, &base64_message);
 
     buzz::XmlElement* eke_tag = new buzz::XmlElement(kEkeTag);
     eke_tag->SetBodyText(base64_message);
     message->AddElement(eke_tag);
@@ skipping 13 matching lines @@
   if (state_ != ACCEPTED) {
     state_ = WAITING_MESSAGE;
   }
   return message;
 }
 
 const std::string& V2Authenticator::GetAuthKey() const {
   return auth_key_;
 }
 
-scoped_ptr<ChannelAuthenticator>
+std::unique_ptr<ChannelAuthenticator>
 V2Authenticator::CreateChannelAuthenticator() const {
   DCHECK_EQ(state(), ACCEPTED);
   CHECK(!auth_key_.empty());
 
   if (is_host_side()) {
     return SslHmacChannelAuthenticator::CreateForHost(
         local_cert_, local_key_pair_, auth_key_);
   } else {
     return SslHmacChannelAuthenticator::CreateForClient(
         remote_cert_, auth_key_);
   }
 }
 
 bool V2Authenticator::is_host_side() const {
   return local_key_pair_.get() != nullptr;
 }
 
 }  // namespace protocol
 }  // namespace remoting