Convert //remoting to use std::unique_ptr

remoting/protocol/negotiating_client_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_client_authenticator.h"
 
 #include <algorithm>
 #include <sstream>
 #include <utility>
 
 #include "base/bind.h"
 #include "base/callback.h"
 #include "base/logging.h"
+#include "base/memory/ptr_util.h"
 #include "base/strings/string_split.h"
 #include "remoting/protocol/auth_util.h"
 #include "remoting/protocol/channel_authenticator.h"
 #include "remoting/protocol/pairing_client_authenticator.h"
 #include "remoting/protocol/spake2_authenticator.h"
 #include "remoting/protocol/v2_authenticator.h"
 #include "third_party/webrtc/libjingle/xmllite/xmlelement.h"
 
 namespace remoting {
 namespace protocol {
@@ skipping 49 matching lines @@
     base::Closure callback = base::Bind(
         &NegotiatingAuthenticatorBase::ProcessMessageInternal,
         base::Unretained(this), base::Owned(new buzz::XmlElement(*message)),
         resume_callback);
     CreateAuthenticatorForCurrentMethod(WAITING_MESSAGE, callback);
     return;
   }
   ProcessMessageInternal(message, resume_callback);
 }
 
-scoped_ptr<buzz::XmlElement> NegotiatingClientAuthenticator::GetNextMessage() {
+std::unique_ptr<buzz::XmlElement>
+NegotiatingClientAuthenticator::GetNextMessage() {
   DCHECK_EQ(state(), MESSAGE_READY);
 
   // This is the first message to the host, send a list of supported methods.
   if (current_method_ == Method::INVALID) {
     // If no authentication method has been chosen, see if we can optimistically
     // choose one.
-    scoped_ptr<buzz::XmlElement> result;
+    std::unique_ptr<buzz::XmlElement> result;
     CreatePreferredAuthenticator();
     if (current_authenticator_) {
       DCHECK(current_authenticator_->state() == MESSAGE_READY);
       result = GetNextMessageInternal();
     } else {
       result = CreateEmptyAuthenticatorMessage();
     }
 
     if (is_paired()) {
       // If the client is paired with the host then attach pairing client_id to
@@ skipping 39 matching lines @@
           base::Bind(&Spake2Authenticator::CreateForClient, local_id_,
                      remote_id_),
           config_.fetch_third_party_token_callback));
       resume_callback.Run();
       break;
 
     case Method::PAIRED_SPAKE2_P224: {
       PairingClientAuthenticator* pairing_authenticator =
           new PairingClientAuthenticator(
               config_, base::Bind(&V2Authenticator::CreateForClient));
-      current_authenticator_ = make_scoped_ptr(pairing_authenticator);
+      current_authenticator_ = base::WrapUnique(pairing_authenticator);
       pairing_authenticator->Start(preferred_initial_state, resume_callback);
       break;
     }
 
     case Method::PAIRED_SPAKE2_CURVE25519: {
       PairingClientAuthenticator* pairing_authenticator =
           new PairingClientAuthenticator(
               config_, base::Bind(&Spake2Authenticator::CreateForClient,
                                   local_id_, remote_id_));
-      current_authenticator_ = make_scoped_ptr(pairing_authenticator);
+      current_authenticator_ = base::WrapUnique(pairing_authenticator);
       pairing_authenticator->Start(preferred_initial_state, resume_callback);
       break;
     }
 
     case Method::SHARED_SECRET_SPAKE2_P224:
     case Method::SHARED_SECRET_SPAKE2_CURVE25519:
       config_.fetch_secret_callback.Run(
           false,
           base::Bind(
               &NegotiatingClientAuthenticator::CreateSharedSecretAuthenticator,
               weak_factory_.GetWeakPtr(), preferred_initial_state,
               resume_callback));
       break;
   }
 }
 
 void NegotiatingClientAuthenticator::CreatePreferredAuthenticator() {
   if (is_paired() &&
       std::find(methods_.begin(), methods_.end(), Method::PAIRED_SPAKE2_P224) !=
           methods_.end()) {
     PairingClientAuthenticator* pairing_authenticator =
         new PairingClientAuthenticator(
             config_, base::Bind(&V2Authenticator::CreateForClient));
-    current_authenticator_ = make_scoped_ptr(pairing_authenticator);
+    current_authenticator_ = base::WrapUnique(pairing_authenticator);
     pairing_authenticator->StartPaired(MESSAGE_READY);
     current_method_ = Method::PAIRED_SPAKE2_P224;
   }
 }
 
 void NegotiatingClientAuthenticator::CreateSharedSecretAuthenticator(
     Authenticator::State initial_state,
     const base::Closure& resume_callback,
     const std::string& shared_secret) {
   std::string shared_secret_hash =
       GetSharedSecretHash(config_.host_id, shared_secret);
   if (current_method_ == Method::SHARED_SECRET_SPAKE2_CURVE25519) {
     current_authenticator_ = Spake2Authenticator::CreateForClient(
         local_id_, remote_id_, shared_secret_hash, initial_state);
   } else {
     current_authenticator_ =
         V2Authenticator::CreateForClient(shared_secret_hash, initial_state);
   }
   resume_callback.Run();
 }
 
 bool NegotiatingClientAuthenticator::is_paired() {
   return !config_.pairing_client_id.empty() && !config_.pairing_secret.empty();
 }
 
 }  // namespace protocol
 }  // namespace remoting