Convert //remoting to use std::unique_ptr

remoting/protocol/negotiating_authenticator_unittest.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 "base/bind.h"
 #include "base/macros.h"
+#include "base/memory/ptr_util.h"
 #include "net/base/net_errors.h"
 #include "remoting/base/rsa_key_pair.h"
 #include "remoting/protocol/auth_util.h"
 #include "remoting/protocol/authenticator_test_base.h"
 #include "remoting/protocol/channel_authenticator.h"
 #include "remoting/protocol/connection_tester.h"
 #include "remoting/protocol/negotiating_authenticator_base.h"
 #include "remoting/protocol/negotiating_client_authenticator.h"
 #include "remoting/protocol/negotiating_host_authenticator.h"
 #include "remoting/protocol/pairing_registry.h"
@@ skipping 35 matching lines @@
   NegotiatingAuthenticatorTest() {}
   ~NegotiatingAuthenticatorTest() override {}
 
  protected:
   virtual void InitAuthenticators(const std::string& client_id,
                                   const std::string& client_paired_secret,
                                   const std::string& client_interactive_pin,
                                   const std::string& host_secret) {
     std::string host_secret_hash =
         GetSharedSecretHash(kTestHostId, host_secret);
-    scoped_ptr<NegotiatingHostAuthenticator> host =
+    std::unique_ptr<NegotiatingHostAuthenticator> host =
         NegotiatingHostAuthenticator::CreateWithSharedSecret(
             kHostJid, kClientJid, host_cert_, key_pair_, host_secret_hash,
             pairing_registry_);
     host_as_negotiating_authenticator_ = host.get();
     host_ = std::move(host);
 
     protocol::ClientAuthenticationConfig client_auth_config;
     client_auth_config.host_id = kTestHostId;
     client_auth_config.pairing_client_id = client_id;
     client_auth_config.pairing_secret = client_paired_secret;
@@ skipping 15 matching lines @@
 
   void DisableMethodOnHost(NegotiatingAuthenticatorBase::Method method) {
     auto* methods = &(host_as_negotiating_authenticator_->methods_);
     auto iter = std::find(methods->begin(), methods->end(), method);
     ASSERT_TRUE(iter != methods->end());
     methods->erase(iter);
   }
 
   void CreatePairingRegistry(bool with_paired_client) {
     pairing_registry_ = new SynchronousPairingRegistry(
-        make_scoped_ptr(new MockPairingRegistryDelegate()));
+        base::WrapUnique(new MockPairingRegistryDelegate()));
     if (with_paired_client) {
       PairingRegistry::Pairing pairing(
           base::Time(), kTestClientName, kTestClientId, kTestPairedSecret);
       pairing_registry_->AddPairing(pairing);
     }
   }
 
   static void FetchSecret(
       const std::string& client_secret,
       bool pairing_supported,
@@ skipping 199 matching lines @@
 TEST_P(NegotiatingPairingAuthenticatorTest, PairingFailedInvalidSecretAndPin) {
   CreatePairingRegistry(true);
   ASSERT_NO_FATAL_FAILURE(InitAuthenticators(
       kTestClientId, kTestPairedSecretBad, kTestPinBad, kTestPin));
   ASSERT_NO_FATAL_FAILURE(RunAuthExchange());
   VerifyRejected(Authenticator::INVALID_CREDENTIALS);
 }
 
 }  // namespace protocol
 }  // namespace remoting