Replace scoped_ptr with unique_ptr in webrtc/p2p/

webrtc/p2p/quic/quictransportchannel_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/quictransportchannel.h"
 
+#include <memory>
 #include <set>
 #include <string>
 #include <vector>
 
 #include "webrtc/base/common.h"
 #include "webrtc/base/gunit.h"
-#include "webrtc/base/scoped_ptr.h"
 #include "webrtc/base/sslidentity.h"
 #include "webrtc/p2p/base/faketransportcontroller.h"
 
 using cricket::ConnectionRole;
 using cricket::IceRole;
 using cricket::QuicTransportChannel;
 using cricket::ReliableQuicStream;
 using cricket::TransportChannel;
 using cricket::TransportDescription;
 
@@ skipping 66 matching lines @@
         bytes_sent_(0),
         ice_channel_(name_, 0),
         quic_channel_(&ice_channel_) {
     quic_channel_.SignalReadPacket.connect(
         this, &QuicTestPeer::OnTransportChannelReadPacket);
     quic_channel_.SignalIncomingStream.connect(this,
                                                &QuicTestPeer::OnIncomingStream);
     quic_channel_.SignalClosed.connect(this, &QuicTestPeer::OnClosed);
     ice_channel_.SetAsync(true);
     rtc::scoped_refptr<rtc::RTCCertificate> local_cert =
-        rtc::RTCCertificate::Create(rtc::scoped_ptr<rtc::SSLIdentity>(
+        rtc::RTCCertificate::Create(std::unique_ptr<rtc::SSLIdentity>(
             rtc::SSLIdentity::Generate(name_, rtc::KT_DEFAULT)));
     quic_channel_.SetLocalCertificate(local_cert);
     local_fingerprint_.reset(CreateFingerprint(local_cert.get()));
   }
 
   // Connects |ice_channel_| to that of the other peer.
   void Connect(QuicTestPeer* other_peer) {
     ice_channel_.Connect();
     other_peer->ice_channel_.Connect();
     ice_channel_.SetDestination(&other_peer->ice_channel_);
@@ skipping 24 matching lines @@
   }
 
   // Creates fingerprint from certificate.
   rtc::SSLFingerprint* CreateFingerprint(rtc::RTCCertificate* cert) {
     std::string digest_algorithm;
     bool get_digest_algorithm =
         cert->ssl_certificate().GetSignatureDigestAlgorithm(&digest_algorithm);
     if (!get_digest_algorithm || digest_algorithm.empty()) {
       return nullptr;
     }
-    rtc::scoped_ptr<rtc::SSLFingerprint> fingerprint(
+    std::unique_ptr<rtc::SSLFingerprint> fingerprint(
         rtc::SSLFingerprint::Create(digest_algorithm, cert->identity()));
     if (digest_algorithm != rtc::DIGEST_SHA_256) {
       return nullptr;
     }
     return fingerprint.release();
   }
 
   // Sends SRTP packet to the other peer via |quic_channel_|.
   int SendSrtpPacket() {
     char packet[kPacketSize];
@@ skipping 29 matching lines @@
   void SetWriteError(int error) { ice_channel_.SetError(error); }
 
   size_t bytes_received() const { return bytes_received_; }
 
   size_t bytes_sent() const { return bytes_sent_; }
 
   FailableTransportChannel* ice_channel() { return &ice_channel_; }
 
   QuicTransportChannel* quic_channel() { return &quic_channel_; }
 
-  rtc::scoped_ptr<rtc::SSLFingerprint>& local_fingerprint() {
+  std::unique_ptr<rtc::SSLFingerprint>& local_fingerprint() {
     return local_fingerprint_;
   }
 
   ReliableQuicStream* incoming_quic_stream() { return incoming_quic_stream_; }
 
   bool signal_closed_emitted() const { return signal_closed_emitted_; }
 
  private:
   // QuicTransportChannel callbacks.
   void OnTransportChannelReadPacket(TransportChannel* channel,
                                     const char* data,
                                     size_t size,
                                     const rtc::PacketTime& packet_time,
                                     int flags) {
     bytes_received_ += size;
     // Only SRTP packets should have the bypass flag set.
     int expected_flags = IsRtpLeadByte(data[0]) ? cricket::PF_SRTP_BYPASS : 0;
     ASSERT_EQ(expected_flags, flags);
   }
   void OnIncomingStream(ReliableQuicStream* stream) {
     incoming_quic_stream_ = stream;
   }
   void OnClosed() { signal_closed_emitted_ = true; }
 
   std::string name_;                      // Channel name.
   size_t bytes_sent_;                     // Bytes sent by QUIC channel.
   size_t bytes_received_;                 // Bytes received by QUIC channel.
   FailableTransportChannel ice_channel_;  // Simulates an ICE channel.
   QuicTransportChannel quic_channel_;     // QUIC channel to test.
-  rtc::scoped_ptr<rtc::SSLFingerprint> local_fingerprint_;
+  std::unique_ptr<rtc::SSLFingerprint> local_fingerprint_;
   ReliableQuicStream* incoming_quic_stream_ = nullptr;
   bool signal_closed_emitted_ = false;
 };
 
 class QuicTransportChannelTest : public testing::Test {
  public:
   QuicTransportChannelTest() : peer1_("P1"), peer2_("P2") {}
 
   // Performs negotiation before QUIC handshake, then connects the fake
   // transport channels of each peer. As a side effect, the QUIC channels
   // start sending handshake messages. |peer1_| has a client role and |peer2_|
   // has server role in the QUIC handshake.
   void Connect() {
     SetIceAndCryptoParameters(rtc::SSL_CLIENT, rtc::SSL_SERVER);
     peer1_.Connect(&peer2_);
   }
 
   // Disconnects the fake transport channels.
   void Disconnect() {
     peer1_.Disconnect();
     peer2_.Disconnect();
   }
 
   // Sets up ICE parameters and exchanges fingerprints before QUIC handshake.
   void SetIceAndCryptoParameters(rtc::SSLRole peer1_ssl_role,
                                  rtc::SSLRole peer2_ssl_role) {
     peer1_.quic_channel()->SetSslRole(peer1_ssl_role);
     peer2_.quic_channel()->SetSslRole(peer2_ssl_role);
 
-    rtc::scoped_ptr<rtc::SSLFingerprint>& peer1_fingerprint =
+    std::unique_ptr<rtc::SSLFingerprint>& peer1_fingerprint =
         peer1_.local_fingerprint();
-    rtc::scoped_ptr<rtc::SSLFingerprint>& peer2_fingerprint =
+    std::unique_ptr<rtc::SSLFingerprint>& peer2_fingerprint =
         peer2_.local_fingerprint();
 
     peer1_.quic_channel()->SetRemoteFingerprint(
         peer2_fingerprint->algorithm,
         reinterpret_cast<const uint8_t*>(peer2_fingerprint->digest.data()),
         peer2_fingerprint->digest.size());
     peer2_.quic_channel()->SetRemoteFingerprint(
         peer1_fingerprint->algorithm,
         reinterpret_cast<const uint8_t*>(peer1_fingerprint->digest.data()),
         peer1_fingerprint->digest.size());
@@ skipping 183 matching lines @@
   ASSERT_TRUE_WAIT(quic_connected(), kTimeoutMs);
   EXPECT_FALSE(peer1_.quic_channel()->SetSslRole(rtc::SSL_SERVER));
   EXPECT_TRUE(peer1_.quic_channel()->SetSslRole(rtc::SSL_CLIENT));
   EXPECT_FALSE(peer2_.quic_channel()->SetSslRole(rtc::SSL_CLIENT));
   EXPECT_TRUE(peer2_.quic_channel()->SetSslRole(rtc::SSL_SERVER));
 }
 
 // Set the SSL role, then test that GetSslRole returns the same value.
 TEST_F(QuicTransportChannelTest, SetGetSslRole) {
   ASSERT_TRUE(peer1_.quic_channel()->SetSslRole(rtc::SSL_SERVER));
-  rtc::scoped_ptr<rtc::SSLRole> role(new rtc::SSLRole());
+  std::unique_ptr<rtc::SSLRole> role(new rtc::SSLRole());
   ASSERT_TRUE(peer1_.quic_channel()->GetSslRole(role.get()));
   EXPECT_EQ(rtc::SSL_SERVER, *role);
 }
 
 // Test that after the QUIC handshake is complete, the QUIC handshake remains
 // confirmed even if the ICE channel reconnects.
 TEST_F(QuicTransportChannelTest, HandshakeConfirmedAfterReconnect) {
   Connect();
   ASSERT_TRUE_WAIT(quic_connected(), kTimeoutMs);
   Disconnect();
@@ skipping 41 matching lines @@
   Connect();
   ASSERT_TRUE_WAIT(quic_connected(), kTimeoutMs);
   ASSERT_FALSE(peer1_.signal_closed_emitted());
   ReliableQuicStream* stream = peer1_.quic_channel()->CreateQuicStream();
   ASSERT_NE(nullptr, stream);
   stream->CloseConnectionWithDetails(net::QuicErrorCode::QUIC_NO_ERROR,
                                      "Closing QUIC for testing");
   EXPECT_TRUE(peer1_.signal_closed_emitted());
   EXPECT_TRUE_WAIT(peer2_.signal_closed_emitted(), kTimeoutMs);
 }