Replace scoped_ptr with unique_ptr everywhere

webrtc/p2p/quic/quictransport_unittest.cc

 /*
  *  Copyright 2016 The WebRTC Project Authors. All rights reserved.
  *
  *  Use of this source code is governed by a BSD-style license
  *  that can be found in the LICENSE file in the root of the source
  *  tree. An additional intellectual property rights grant can be found
  *  in the file PATENTS.  All contributing project authors may
  *  be found in the AUTHORS file in the root of the source tree.
  */
 
 #include "webrtc/p2p/quic/quictransport.h"
 
+#include <memory>
 #include <string>
 #include <vector>
 
 #include "webrtc/base/gunit.h"
 #include "webrtc/base/rtccertificate.h"
 #include "webrtc/base/sslidentity.h"
 
 using cricket::TransportChannelImpl;
 using cricket::QuicTransport;
 using cricket::Transport;
 using cricket::TransportDescription;
 
 static const char kIceUfrag1[] = "TESTICEUFRAG0001";
 static const char kIcePwd1[] = "TESTICEPWD00000000000001";
 
 static const char kIceUfrag2[] = "TESTICEUFRAG0002";
 static const char kIcePwd2[] = "TESTICEPWD00000000000002";
 
 static rtc::scoped_refptr<rtc::RTCCertificate> CreateCertificate(
     std::string name) {
-  return rtc::RTCCertificate::Create(rtc::scoped_ptr<rtc::SSLIdentity>(
+  return rtc::RTCCertificate::Create(std::unique_ptr<rtc::SSLIdentity>(
       rtc::SSLIdentity::Generate(name, rtc::KT_DEFAULT)));
 }
 
-static rtc::scoped_ptr<rtc::SSLFingerprint> CreateFingerprint(
+static std::unique_ptr<rtc::SSLFingerprint> CreateFingerprint(
     rtc::RTCCertificate* cert) {
   std::string digest_algorithm;
   cert->ssl_certificate().GetSignatureDigestAlgorithm(&digest_algorithm);
-  return rtc::scoped_ptr<rtc::SSLFingerprint>(
+  return std::unique_ptr<rtc::SSLFingerprint>(
       rtc::SSLFingerprint::Create(digest_algorithm, cert->identity()));
 }
 
 class QuicTransportTest : public testing::Test {
  public:
   QuicTransportTest() : transport_("testing", nullptr, nullptr) {}
 
   void SetTransportDescription(cricket::ConnectionRole local_role,
                                cricket::ConnectionRole remote_role,
                                cricket::ContentAction local_action,
                                cricket::ContentAction remote_action,
                                rtc::SSLRole expected_ssl_role) {
     TransportChannelImpl* channel = transport_.CreateChannel(1);
     ASSERT_NE(nullptr, channel);
 
     rtc::scoped_refptr<rtc::RTCCertificate> local_certificate(
         CreateCertificate("local"));
     ASSERT_NE(nullptr, local_certificate);
     transport_.SetLocalCertificate(local_certificate);
 
-    rtc::scoped_ptr<rtc::SSLFingerprint> local_fingerprint =
+    std::unique_ptr<rtc::SSLFingerprint> local_fingerprint =
         CreateFingerprint(local_certificate.get());
     ASSERT_NE(nullptr, local_fingerprint);
     TransportDescription local_desc(std::vector<std::string>(), kIceUfrag1,
                                     kIcePwd1, cricket::ICEMODE_FULL, local_role,
                                     local_fingerprint.get());
     ASSERT_TRUE(transport_.SetLocalTransportDescription(local_desc,
                                                         local_action, nullptr));
     // The certificate is applied to QuicTransportChannel when the local
     // description is set.
     rtc::scoped_refptr<rtc::RTCCertificate> channel_local_certificate =
         channel->GetLocalCertificate();
     ASSERT_NE(nullptr, channel_local_certificate);
     EXPECT_EQ(local_certificate, channel_local_certificate);
-    rtc::scoped_ptr<rtc::SSLFingerprint> remote_fingerprint =
+    std::unique_ptr<rtc::SSLFingerprint> remote_fingerprint =
         CreateFingerprint(CreateCertificate("remote").get());
     // NegotiateTransportDescription was not called yet. The SSL role should
     // not be set and neither should the remote fingerprint.
-    rtc::scoped_ptr<rtc::SSLRole> role(new rtc::SSLRole());
+    std::unique_ptr<rtc::SSLRole> role(new rtc::SSLRole());
     EXPECT_FALSE(channel->GetSslRole(role.get()));
     // Setting the remote description should set the SSL role.
     ASSERT_NE(nullptr, remote_fingerprint);
     TransportDescription remote_desc(std::vector<std::string>(), kIceUfrag2,
                                      kIcePwd2, cricket::ICEMODE_FULL,
                                      remote_role, remote_fingerprint.get());
     ASSERT_TRUE(transport_.SetRemoteTransportDescription(
         remote_desc, remote_action, nullptr));
     ASSERT_TRUE(channel->GetSslRole(role.get()));
     // SSL role should be client because the remote description is an ANSWER.
@@ skipping 59 matching lines @@
   ASSERT_NE(nullptr, channel2);
   EXPECT_TRUE(transport_.HasChannel(2));
   EXPECT_EQ(channel2, transport_.GetChannel(2));
   transport_.DestroyChannel(1);
   EXPECT_FALSE(transport_.HasChannel(1));
   EXPECT_EQ(nullptr, transport_.GetChannel(1));
   transport_.DestroyChannel(2);
   EXPECT_FALSE(transport_.HasChannel(2));
   EXPECT_EQ(nullptr, transport_.GetChannel(2));
 }