Convert //remoting to use std::unique_ptr

remoting/protocol/spake2_authenticator.cc

 // Copyright 2016 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/spake2_authenticator.h"
 
 #include <utility>
 
 #include "base/base64.h"
 #include "base/logging.h"
+#include "base/memory/ptr_util.h"
 #include "base/sys_byteorder.h"
 #include "crypto/hmac.h"
 #include "crypto/secure_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/boringssl/src/include/openssl/curve25519.h"
 #include "third_party/webrtc/libjingle/xmllite/xmlelement.h"
 
 namespace remoting {
@@ skipping 12 matching lines @@
 //                remote_jid.length() + remote_jid)
 // where auth_key is the key produced by SPAKE2.
 
 const buzz::StaticQName kSpakeMessageTag = {kChromotingXmlNamespace,
                                             "spake-message"};
 const buzz::StaticQName kVerificationHashTag = {kChromotingXmlNamespace,
                                                 "verification-hash"};
 const buzz::StaticQName kCertificateTag = {kChromotingXmlNamespace,
                                            "certificate"};
 
-scoped_ptr<buzz::XmlElement> EncodeBinaryValueToXml(
+std::unique_ptr<buzz::XmlElement> EncodeBinaryValueToXml(
     const buzz::StaticQName& qname,
     const std::string& content) {
   std::string content_base64;
   base::Base64Encode(content, &content_base64);
 
-  scoped_ptr<buzz::XmlElement> result(new buzz::XmlElement(qname));
+  std::unique_ptr<buzz::XmlElement> result(new buzz::XmlElement(qname));
   result->SetBodyText(content_base64);
   return result;
 }
 
 // Finds tag named |qname| in base_message and decodes it from base64 and stores
 // in |data|. If the element is not present then found is set to false otherwise
 // it's set to true. If the element is there and it's content cound't be decoded
 // then false is returned.
 bool DecodeBinaryValueFromXml(const buzz::XmlElement* message,
                               const buzz::QName& qname,
@@ skipping 13 matching lines @@
 }
 
 std::string PrefixWithLength(const std::string& str) {
   uint32_t length = base::HostToNet32(str.size());
   return std::string(reinterpret_cast<char*>(&length), sizeof(length)) + str;
 }
 
 }  // namespace
 
 // static
-scoped_ptr<Authenticator> Spake2Authenticator::CreateForClient(
+std::unique_ptr<Authenticator> Spake2Authenticator::CreateForClient(
     const std::string& local_id,
     const std::string& remote_id,
     const std::string& shared_secret,
     Authenticator::State initial_state) {
-  return make_scoped_ptr(new Spake2Authenticator(
+  return base::WrapUnique(new Spake2Authenticator(
       local_id, remote_id, shared_secret, false, initial_state));
 }
 
 // static
-scoped_ptr<Authenticator> Spake2Authenticator::CreateForHost(
+std::unique_ptr<Authenticator> Spake2Authenticator::CreateForHost(
     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,
     Authenticator::State initial_state) {
-  scoped_ptr<Spake2Authenticator> result(new Spake2Authenticator(
+  std::unique_ptr<Spake2Authenticator> result(new Spake2Authenticator(
       local_id, remote_id, shared_secret, true, initial_state));
   result->local_cert_ = local_cert;
   result->local_key_pair_ = key_pair;
   return std::move(result);
 }
 
 Spake2Authenticator::Spake2Authenticator(const std::string& local_id,
                                          const std::string& remote_id,
                                          const std::string& shared_secret,
                                          bool is_host,
@@ skipping 129 matching lines @@
       rejection_reason_ = INVALID_CREDENTIALS;
       return;
     }
     state_ = ACCEPTED;
     return;
   }
 
   state_ = MESSAGE_READY;
 }
 
-scoped_ptr<buzz::XmlElement> Spake2Authenticator::GetNextMessage() {
+std::unique_ptr<buzz::XmlElement> Spake2Authenticator::GetNextMessage() {
   DCHECK_EQ(state(), MESSAGE_READY);
 
-  scoped_ptr<buzz::XmlElement> message = CreateEmptyAuthenticatorMessage();
+  std::unique_ptr<buzz::XmlElement> message = CreateEmptyAuthenticatorMessage();
 
   if (!spake_message_sent_) {
     if (!local_cert_.empty()) {
       message->AddElement(
           EncodeBinaryValueToXml(kCertificateTag, local_cert_).release());
     }
 
     message->AddElement(
         EncodeBinaryValueToXml(kSpakeMessageTag, local_spake_message_)
             .release());
@@ skipping 11 matching lines @@
   if (state_ != ACCEPTED) {
     state_ = WAITING_MESSAGE;
   }
   return message;
 }
 
 const std::string& Spake2Authenticator::GetAuthKey() const {
   return auth_key_;
 }
 
-scoped_ptr<ChannelAuthenticator>
+std::unique_ptr<ChannelAuthenticator>
 Spake2Authenticator::CreateChannelAuthenticator() const {
   DCHECK_EQ(state(), ACCEPTED);
   CHECK(!auth_key_.empty());
 
   if (is_host_) {
     return SslHmacChannelAuthenticator::CreateForHost(
         local_cert_, local_key_pair_, auth_key_);
   } else {
     return SslHmacChannelAuthenticator::CreateForClient(remote_cert_,
                                                         auth_key_);
@@ skipping 12 matching lines @@
   if (!hmac.Init(auth_key_) ||
       !hmac.Sign(message, reinterpret_cast<uint8_t*>(&result[0]),
                  result.length())) {
     LOG(FATAL) << "Failed to calculate HMAC.";
   }
   return result;
 }
 
 }  // namespace protocol
 }  // namespace remoting