Replace scoped_ptr with unique_ptr in webrtc/p2p/

webrtc/p2p/quic/quicsession_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/quicsession.h"
 
+#include <memory>
 #include <string>
 #include <vector>
 
 #include "net/base/ip_endpoint.h"
 #include "net/quic/crypto/crypto_server_config_protobuf.h"
 #include "net/quic/crypto/quic_random.h"
 #include "net/quic/crypto/proof_source.h"
 #include "net/quic/crypto/proof_verifier.h"
 #include "net/quic/crypto/quic_crypto_client_config.h"
 #include "net/quic/crypto/quic_crypto_server_config.h"
@@ skipping 87 matching lines @@
 
   // ProofVerifier override
   net::QuicAsyncStatus VerifyProof(
       const std::string& hostname,
       const std::string& server_config,
       const std::vector<std::string>& certs,
       const std::string& cert_sct,
       const std::string& signature,
       const net::ProofVerifyContext* verify_context,
       std::string* error_details,
-      scoped_ptr<net::ProofVerifyDetails>* verify_details,
+      std::unique_ptr<net::ProofVerifyDetails>* verify_details,
       net::ProofVerifierCallback* callback) override {
     return success_ ? net::QUIC_SUCCESS : net::QUIC_FAILURE;
   }
 
  private:
   // Whether or not proof verification succeeds.
   bool success_;
 };
 
 // Writes QUIC packets to a fake transport channel that simulates a network.
@@ skipping 41 matching lines @@
     return net::kMaxPacketSize;
   }
 
  private:
   FakeTransportChannel* fake_channel_;
 };
 
 // Wrapper for QuicSession and transport channel that stores incoming data.
 class QuicSessionForTest : public QuicSession {
  public:
-  QuicSessionForTest(rtc::scoped_ptr<net::QuicConnection> connection,
+  QuicSessionForTest(std::unique_ptr<net::QuicConnection> connection,
                      const net::QuicConfig& config,
-                     rtc::scoped_ptr<FakeTransportChannel> channel)
+                     std::unique_ptr<FakeTransportChannel> channel)
       : QuicSession(std::move(connection), config),
         channel_(std::move(channel)) {
     channel_->SignalReadPacket.connect(
         this, &QuicSessionForTest::OnChannelReadPacket);
   }
 
   // Called when channel has packets to read.
   void OnChannelReadPacket(TransportChannel* channel,
                            const char* data,
                            size_t size,
@@ skipping 17 matching lines @@
   std::string data() { return last_received_data_; }
 
   bool has_data() { return data().size() > 0; }
 
   FakeTransportChannel* channel() { return channel_.get(); }
 
   ReliableQuicStream* incoming_stream() { return last_incoming_stream_; }
 
  private:
   // Transports QUIC packets to/from peer.
-  rtc::scoped_ptr<FakeTransportChannel> channel_;
+  std::unique_ptr<FakeTransportChannel> channel_;
   // Stores data received by peer once it is sent from the other peer.
   std::string last_received_data_;
   // Handles incoming streams from sender.
   ReliableQuicStream* last_incoming_stream_ = nullptr;
 };
 
 // Simulates data transfer between two peers using QUIC.
 class QuicSessionTest : public ::testing::Test,
                         public QuicCryptoClientStream::ProofHandler {
  public:
   QuicSessionTest() : quic_helper_(rtc::Thread::Current()) {}
 
   // Instantiates |client_peer_| and |server_peer_|.
   void CreateClientAndServerSessions();
 
-  rtc::scoped_ptr<QuicSessionForTest> CreateSession(
-      rtc::scoped_ptr<FakeTransportChannel> channel,
+  std::unique_ptr<QuicSessionForTest> CreateSession(
+      std::unique_ptr<FakeTransportChannel> channel,
       Perspective perspective);
 
   QuicCryptoClientStream* CreateCryptoClientStream(QuicSessionForTest* session,
                                                    bool handshake_success);
   QuicCryptoServerStream* CreateCryptoServerStream(QuicSessionForTest* session,
                                                    bool handshake_success);
 
-  rtc::scoped_ptr<QuicConnection> CreateConnection(
+  std::unique_ptr<QuicConnection> CreateConnection(
       FakeTransportChannel* channel,
       Perspective perspective);
 
   void StartHandshake(bool client_handshake_success,
                       bool server_handshake_success);
 
   // Test handshake establishment and sending/receiving of data.
   void TestStreamConnection(QuicSessionForTest* from_session,
                             QuicSessionForTest* to_session);
   // Test that client and server are not connected after handshake failure.
   void TestDisconnectAfterFailedHandshake();
 
   // QuicCryptoClientStream::ProofHelper overrides.
   void OnProofValid(
       const QuicCryptoClientConfig::CachedState& cached) override {}
   void OnProofVerifyDetailsAvailable(
       const ProofVerifyDetails& verify_details) override {}
 
  protected:
   QuicConnectionHelper quic_helper_;
   QuicConfig config_;
   QuicClock clock_;
 
-  rtc::scoped_ptr<QuicSessionForTest> client_peer_;
-  rtc::scoped_ptr<QuicSessionForTest> server_peer_;
+  std::unique_ptr<QuicSessionForTest> client_peer_;
+  std::unique_ptr<QuicSessionForTest> server_peer_;
 };
 
 // Initializes "client peer" who begins crypto handshake and "server peer" who
 // establishes encryption with client.
 void QuicSessionTest::CreateClientAndServerSessions() {
-  rtc::scoped_ptr<FakeTransportChannel> channel1(
+  std::unique_ptr<FakeTransportChannel> channel1(
       new FakeTransportChannel("channel1", 0));
-  rtc::scoped_ptr<FakeTransportChannel> channel2(
+  std::unique_ptr<FakeTransportChannel> channel2(
       new FakeTransportChannel("channel2", 0));
 
   // Prevent channel1->OnReadPacket and channel2->OnReadPacket from calling
   // themselves in a loop, which causes to future packets to be recursively
   // consumed while the current thread blocks consumption of current ones.
   channel2->SetAsync(true);
 
   // Configure peers to send packets to each other.
   channel1->Connect();
   channel2->Connect();
   channel1->SetDestination(channel2.get());
 
   client_peer_ = CreateSession(std::move(channel1), Perspective::IS_CLIENT);
   server_peer_ = CreateSession(std::move(channel2), Perspective::IS_SERVER);
 }
 
-rtc::scoped_ptr<QuicSessionForTest> QuicSessionTest::CreateSession(
-    rtc::scoped_ptr<FakeTransportChannel> channel,
+std::unique_ptr<QuicSessionForTest> QuicSessionTest::CreateSession(
+    std::unique_ptr<FakeTransportChannel> channel,
     Perspective perspective) {
-  rtc::scoped_ptr<QuicConnection> quic_connection =
+  std::unique_ptr<QuicConnection> quic_connection =
       CreateConnection(channel.get(), perspective);
-  return rtc::scoped_ptr<QuicSessionForTest>(new QuicSessionForTest(
+  return std::unique_ptr<QuicSessionForTest>(new QuicSessionForTest(
       std::move(quic_connection), config_, std::move(channel)));
 }
 
 QuicCryptoClientStream* QuicSessionTest::CreateCryptoClientStream(
     QuicSessionForTest* session,
     bool handshake_success) {
   QuicCryptoClientConfig* client_config =
       new QuicCryptoClientConfig(new FakeProofVerifier(handshake_success));
   return new QuicCryptoClientStream(
       kServerId, session, new ProofVerifyContext(), client_config, this);
 }
 
 QuicCryptoServerStream* QuicSessionTest::CreateCryptoServerStream(
     QuicSessionForTest* session,
     bool handshake_success) {
   QuicCryptoServerConfig* server_config =
       new QuicCryptoServerConfig("TESTING", QuicRandom::GetInstance(),
                                  new FakeProofSource(handshake_success));
   // Provide server with serialized config string to prove ownership.
   QuicCryptoServerConfig::ConfigOptions options;
   QuicServerConfigProtobuf* primary_config = server_config->GenerateConfig(
       QuicRandom::GetInstance(), &clock_, options);
   server_config->AddConfig(primary_config, clock_.WallNow());
   return new QuicCryptoServerStream(server_config, session);
 }
 
-rtc::scoped_ptr<QuicConnection> QuicSessionTest::CreateConnection(
+std::unique_ptr<QuicConnection> QuicSessionTest::CreateConnection(
     FakeTransportChannel* channel,
     Perspective perspective) {
   FakeQuicPacketWriter* writer = new FakeQuicPacketWriter(channel);
 
   IPAddress ip(0, 0, 0, 0);
   bool owns_writer = true;
 
-  return rtc::scoped_ptr<QuicConnection>(new QuicConnection(
+  return std::unique_ptr<QuicConnection>(new QuicConnection(
       0, net::IPEndPoint(ip, 0), &quic_helper_, writer, owns_writer,
       perspective, net::QuicSupportedVersions()));
 }
 
 void QuicSessionTest::StartHandshake(bool client_handshake_success,
                                      bool server_handshake_success) {
   server_peer_->StartServerHandshake(
       CreateCryptoServerStream(server_peer_.get(), server_handshake_success));
   client_peer_->StartClientHandshake(
       CreateCryptoClientStream(client_peer_.get(), client_handshake_success));
@@ skipping 109 matching lines @@
   StartHandshake(true, true);
   ASSERT_TRUE_WAIT(client_peer_->IsCryptoHandshakeConfirmed() &&
                        server_peer_->IsCryptoHandshakeConfirmed(),
                    kTimeoutMs);
   ReliableQuicStream* stream = client_peer_->CreateOutgoingDynamicStream(5);
   ASSERT_NE(nullptr, stream);
   EXPECT_FALSE(client_peer_->IsClosedStream(stream->id()));
   stream->Close();
   EXPECT_TRUE(client_peer_->IsClosedStream(stream->id()));
 }