Replace scoped_ptr with unique_ptr in webrtc/api/

webrtc/api/peerconnection_unittest.cc

 /*
  *  Copyright 2012 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 <stdio.h>
 
 #include <algorithm>
 #include <list>
 #include <map>
+#include <memory>
 #include <utility>
 #include <vector>
 
 #include "webrtc/api/dtmfsender.h"
 #include "webrtc/api/fakemetricsobserver.h"
 #include "webrtc/api/localaudiosource.h"
 #include "webrtc/api/mediastreaminterface.h"
 #include "webrtc/api/peerconnection.h"
 #include "webrtc/api/peerconnectionfactory.h"
 #include "webrtc/api/peerconnectioninterface.h"
 #include "webrtc/api/test/fakeaudiocapturemodule.h"
 #include "webrtc/api/test/fakeconstraints.h"
 #include "webrtc/api/test/fakedtlsidentitystore.h"
 #include "webrtc/api/test/fakeperiodicvideocapturer.h"
 #include "webrtc/api/test/fakevideotrackrenderer.h"
 #include "webrtc/api/test/mockpeerconnectionobservers.h"
 #include "webrtc/base/gunit.h"
 #include "webrtc/base/physicalsocketserver.h"
-#include "webrtc/base/scoped_ptr.h"
 #include "webrtc/base/ssladapter.h"
 #include "webrtc/base/sslstreamadapter.h"
 #include "webrtc/base/thread.h"
 #include "webrtc/base/virtualsocketserver.h"
 #include "webrtc/media/engine/fakewebrtcvideoengine.h"
 #include "webrtc/p2p/base/p2pconstants.h"
 #include "webrtc/p2p/base/sessiondescription.h"
 #include "webrtc/p2p/client/fakeportallocator.h"
 #include "webrtc/pc/mediasession.h"
 
@@ skipping 102 matching lines @@
 };
 
 class PeerConnectionTestClient : public webrtc::PeerConnectionObserver,
                                  public SignalingMessageReceiver,
                                  public ObserverInterface {
  public:
   static PeerConnectionTestClient* CreateClientWithDtlsIdentityStore(
       const std::string& id,
       const MediaConstraintsInterface* constraints,
       const PeerConnectionFactory::Options* options,
-      rtc::scoped_ptr<webrtc::DtlsIdentityStoreInterface> dtls_identity_store,
+      std::unique_ptr<webrtc::DtlsIdentityStoreInterface> dtls_identity_store,
       bool prefer_constraint_apis,
       rtc::Thread* worker_thread) {
     PeerConnectionTestClient* client(new PeerConnectionTestClient(id));
     if (!client->Init(constraints, options, std::move(dtls_identity_store),
                       prefer_constraint_apis, worker_thread)) {
       delete client;
       return nullptr;
     }
     return client;
   }
 
   static PeerConnectionTestClient* CreateClient(
       const std::string& id,
       const MediaConstraintsInterface* constraints,
       const PeerConnectionFactory::Options* options,
       rtc::Thread* worker_thread) {
-    rtc::scoped_ptr<FakeDtlsIdentityStore> dtls_identity_store(
+    std::unique_ptr<FakeDtlsIdentityStore> dtls_identity_store(
         rtc::SSLStreamAdapter::HaveDtlsSrtp() ? new FakeDtlsIdentityStore()
                                               : nullptr);
 
     return CreateClientWithDtlsIdentityStore(id, constraints, options,
                                              std::move(dtls_identity_store),
                                              true, worker_thread);
   }
 
   static PeerConnectionTestClient* CreateClientPreferNoConstraints(
       const std::string& id,
       const PeerConnectionFactory::Options* options,
       rtc::Thread* worker_thread) {
-    rtc::scoped_ptr<FakeDtlsIdentityStore> dtls_identity_store(
+    std::unique_ptr<FakeDtlsIdentityStore> dtls_identity_store(
         rtc::SSLStreamAdapter::HaveDtlsSrtp() ? new FakeDtlsIdentityStore()
                                               : nullptr);
 
     return CreateClientWithDtlsIdentityStore(id, nullptr, options,
                                              std::move(dtls_identity_store),
                                              false, worker_thread);
   }
 
   ~PeerConnectionTestClient() {
   }
 
   void Negotiate() { Negotiate(true, true); }
 
   void Negotiate(bool audio, bool video) {
-    rtc::scoped_ptr<SessionDescriptionInterface> offer;
+    std::unique_ptr<SessionDescriptionInterface> offer;
     ASSERT_TRUE(DoCreateOffer(&offer));
 
     if (offer->description()->GetContentByName("audio")) {
       offer->description()->GetContentByName("audio")->rejected = !audio;
     }
     if (offer->description()->GetContentByName("video")) {
       offer->description()->GetContentByName("video")->rejected = !video;
     }
 
     std::string sdp;
@@ skipping 11 matching lines @@
     } else {
       HandleIncomingAnswer(msg);
     }
   }
 
   // SignalingMessageReceiver callback.
   void ReceiveIceMessage(const std::string& sdp_mid,
                          int sdp_mline_index,
                          const std::string& msg) override {
     LOG(INFO) << id_ << "ReceiveIceMessage";
-    rtc::scoped_ptr<webrtc::IceCandidateInterface> candidate(
+    std::unique_ptr<webrtc::IceCandidateInterface> candidate(
         webrtc::CreateIceCandidate(sdp_mid, sdp_mline_index, msg, nullptr));
     EXPECT_TRUE(pc()->AddIceCandidate(candidate.get()));
   }
 
   // PeerConnectionObserver callbacks.
   void OnSignalingChange(
       webrtc::PeerConnectionInterface::SignalingState new_state) override {
     EXPECT_EQ(pc()->signaling_state(), new_state);
   }
   void OnAddStream(MediaStreamInterface* media_stream) override {
@@ skipping 297 matching lines @@
       }
       for (const auto& renderer : removed_fake_video_renderers_) {
         total += renderer->num_rendered_frames();
       }
     }
     return total;
   }
 
   // Verify the CreateDtmfSender interface
   void VerifyDtmf() {
-    rtc::scoped_ptr<DummyDtmfObserver> observer(new DummyDtmfObserver());
+    std::unique_ptr<DummyDtmfObserver> observer(new DummyDtmfObserver());
     rtc::scoped_refptr<DtmfSenderInterface> dtmf_sender;
 
     // We can't create a DTMF sender with an invalid audio track or a non local
     // track.
     EXPECT_TRUE(peer_connection_->CreateDtmfSender(nullptr) == nullptr);
     rtc::scoped_refptr<webrtc::AudioTrackInterface> non_localtrack(
         peer_connection_factory_->CreateAudioTrack("dummy_track", nullptr));
     EXPECT_TRUE(peer_connection_->CreateDtmfSender(non_localtrack) == nullptr);
 
     // We should be able to create a DTMF sender from a local track.
@@ skipping 234 matching lines @@
    private:
     bool completed_;
     std::vector<std::string> tones_;
   };
 
   explicit PeerConnectionTestClient(const std::string& id) : id_(id) {}
 
   bool Init(
       const MediaConstraintsInterface* constraints,
       const PeerConnectionFactory::Options* options,
-      rtc::scoped_ptr<webrtc::DtlsIdentityStoreInterface> dtls_identity_store,
+      std::unique_ptr<webrtc::DtlsIdentityStoreInterface> dtls_identity_store,
       bool prefer_constraint_apis,
       rtc::Thread* worker_thread) {
     EXPECT_TRUE(!peer_connection_);
     EXPECT_TRUE(!peer_connection_factory_);
     if (!prefer_constraint_apis) {
       EXPECT_TRUE(!constraints);
     }
     prefer_constraint_apis_ = prefer_constraint_apis;
 
-    rtc::scoped_ptr<cricket::PortAllocator> port_allocator(
+    std::unique_ptr<cricket::PortAllocator> port_allocator(
         new cricket::FakePortAllocator(worker_thread, nullptr));
     fake_audio_capture_module_ = FakeAudioCaptureModule::Create();
 
     if (fake_audio_capture_module_ == nullptr) {
       return false;
     }
     fake_video_decoder_factory_ = new FakeWebRtcVideoDecoderFactory();
     fake_video_encoder_factory_ = new FakeWebRtcVideoEncoderFactory();
     peer_connection_factory_ = webrtc::CreatePeerConnectionFactory(
         worker_thread, rtc::Thread::Current(), fake_audio_capture_module_,
         fake_video_encoder_factory_, fake_video_decoder_factory_);
     if (!peer_connection_factory_) {
       return false;
     }
     if (options) {
       peer_connection_factory_->SetOptions(*options);
     }
     peer_connection_ = CreatePeerConnection(
         std::move(port_allocator), constraints, std::move(dtls_identity_store));
     return peer_connection_.get() != nullptr;
   }
 
   rtc::scoped_refptr<webrtc::PeerConnectionInterface> CreatePeerConnection(
-      rtc::scoped_ptr<cricket::PortAllocator> port_allocator,
+      std::unique_ptr<cricket::PortAllocator> port_allocator,
       const MediaConstraintsInterface* constraints,
-      rtc::scoped_ptr<webrtc::DtlsIdentityStoreInterface> dtls_identity_store) {
+      std::unique_ptr<webrtc::DtlsIdentityStoreInterface> dtls_identity_store) {
     // CreatePeerConnection with RTCConfiguration.
     webrtc::PeerConnectionInterface::RTCConfiguration config;
     webrtc::PeerConnectionInterface::IceServer ice_server;
     ice_server.uri = "stun:stun.l.google.com:19302";
     config.servers.push_back(ice_server);
 
     return peer_connection_factory_->CreatePeerConnection(
         config, constraints, std::move(port_allocator),
         std::move(dtls_identity_store), this);
   }
 
   void HandleIncomingOffer(const std::string& msg) {
     LOG(INFO) << id_ << "HandleIncomingOffer ";
     if (NumberOfLocalMediaStreams() == 0 && auto_add_stream_) {
       // If we are not sending any streams ourselves it is time to add some.
       AddMediaStream(true, true);
     }
-    rtc::scoped_ptr<SessionDescriptionInterface> desc(
+    std::unique_ptr<SessionDescriptionInterface> desc(
         webrtc::CreateSessionDescription("offer", msg, nullptr));
     EXPECT_TRUE(DoSetRemoteDescription(desc.release()));
-    rtc::scoped_ptr<SessionDescriptionInterface> answer;
+    std::unique_ptr<SessionDescriptionInterface> answer;
     EXPECT_TRUE(DoCreateAnswer(&answer));
     std::string sdp;
     EXPECT_TRUE(answer->ToString(&sdp));
     EXPECT_TRUE(DoSetLocalDescription(answer.release()));
     if (signaling_message_receiver_) {
       signaling_message_receiver_->ReceiveSdpMessage(
           webrtc::SessionDescriptionInterface::kAnswer, sdp);
     }
   }
 
   void HandleIncomingAnswer(const std::string& msg) {
     LOG(INFO) << id_ << "HandleIncomingAnswer";
-    rtc::scoped_ptr<SessionDescriptionInterface> desc(
+    std::unique_ptr<SessionDescriptionInterface> desc(
         webrtc::CreateSessionDescription("answer", msg, nullptr));
     EXPECT_TRUE(DoSetRemoteDescription(desc.release()));
   }
 
-  bool DoCreateOfferAnswer(rtc::scoped_ptr<SessionDescriptionInterface>* desc,
+  bool DoCreateOfferAnswer(std::unique_ptr<SessionDescriptionInterface>* desc,
                            bool offer) {
     rtc::scoped_refptr<MockCreateSessionDescriptionObserver>
         observer(new rtc::RefCountedObject<
             MockCreateSessionDescriptionObserver>());
     if (prefer_constraint_apis_) {
       if (offer) {
         pc()->CreateOffer(observer, &offer_answer_constraints_);
       } else {
         pc()->CreateAnswer(observer, &offer_answer_constraints_);
       }
     } else {
       if (offer) {
         pc()->CreateOffer(observer, offer_answer_options_);
       } else {
         pc()->CreateAnswer(observer, offer_answer_options_);
       }
     }
     EXPECT_EQ_WAIT(true, observer->called(), kMaxWaitMs);
     desc->reset(observer->release_desc());
     if (observer->result() && ExpectIceRestart()) {
       EXPECT_EQ(0u, (*desc)->candidates(0)->count());
     }
     return observer->result();
   }
 
-  bool DoCreateOffer(rtc::scoped_ptr<SessionDescriptionInterface>* desc) {
+  bool DoCreateOffer(std::unique_ptr<SessionDescriptionInterface>* desc) {
     return DoCreateOfferAnswer(desc, true);
   }
 
-  bool DoCreateAnswer(rtc::scoped_ptr<SessionDescriptionInterface>* desc) {
+  bool DoCreateAnswer(std::unique_ptr<SessionDescriptionInterface>* desc) {
     return DoCreateOfferAnswer(desc, false);
   }
 
   bool DoSetLocalDescription(SessionDescriptionInterface* desc) {
     rtc::scoped_refptr<MockSetSessionDescriptionObserver>
             observer(new rtc::RefCountedObject<
                 MockSetSessionDescriptionObserver>());
     LOG(INFO) << id_ << "SetLocalDescription ";
     pc()->SetLocalDescription(observer, desc);
     // Ignore the observer result. If we wait for the result with
@@ skipping 52 matching lines @@
   bool prefer_constraint_apis_ = true;
   bool auto_add_stream_ = true;
 
   typedef std::pair<std::string, std::string> IceUfragPwdPair;
   std::map<int, IceUfragPwdPair> ice_ufrag_pwd_;
   bool expect_ice_restart_ = false;
 
   // Needed to keep track of number of frames sent.
   rtc::scoped_refptr<FakeAudioCaptureModule> fake_audio_capture_module_;
   // Needed to keep track of number of frames received.
-  std::map<std::string, rtc::scoped_ptr<webrtc::FakeVideoTrackRenderer>>
+  std::map<std::string, std::unique_ptr<webrtc::FakeVideoTrackRenderer>>
       fake_video_renderers_;
   // Needed to ensure frames aren't received for removed tracks.
-  std::vector<rtc::scoped_ptr<webrtc::FakeVideoTrackRenderer>>
+  std::vector<std::unique_ptr<webrtc::FakeVideoTrackRenderer>>
       removed_fake_video_renderers_;
   // Needed to keep track of number of frames received when external decoder
   // used.
   FakeWebRtcVideoDecoderFactory* fake_video_decoder_factory_ = nullptr;
   FakeWebRtcVideoEncoderFactory* fake_video_encoder_factory_ = nullptr;
   bool video_decoder_factory_enabled_ = false;
   webrtc::FakeConstraints video_constraints_;
 
   // For remote peer communication.
   SignalingMessageReceiver* signaling_message_receiver_ = nullptr;
 
   // Store references to the video capturers we've created, so that we can stop
   // them, if required.
   std::vector<cricket::FakeVideoCapturer*> video_capturers_;
   webrtc::VideoRotation capture_rotation_ = webrtc::kVideoRotation_0;
   // |local_video_renderer_| attached to the first created local video track.
-  rtc::scoped_ptr<webrtc::FakeVideoTrackRenderer> local_video_renderer_;
+  std::unique_ptr<webrtc::FakeVideoTrackRenderer> local_video_renderer_;
 
   webrtc::FakeConstraints offer_answer_constraints_;
   PeerConnectionInterface::RTCOfferAnswerOptions offer_answer_options_;
   bool remove_msid_ = false;  // True if MSID should be removed in received SDP.
   bool remove_bundle_ =
       false;  // True if bundle should be removed in received SDP.
   bool remove_sdes_ =
       false;  // True if a=crypto should be removed in received SDP.
   // |remove_cvo_| is true if extension urn:3gpp:video-orientation should be
   // removed in the received SDP.
   bool remove_cvo_ = false;
 
   rtc::scoped_refptr<DataChannelInterface> data_channel_;
-  rtc::scoped_ptr<MockDataChannelObserver> data_observer_;
+  std::unique_ptr<MockDataChannelObserver> data_observer_;
 };
 
 class P2PTestConductor : public testing::Test {
  public:
   P2PTestConductor()
       : pss_(new rtc::PhysicalSocketServer),
         ss_(new rtc::VirtualSocketServer(pss_.get())),
         ss_scope_(ss_.get()) {
     RTC_CHECK(worker_thread_.Start());
   }
@@ skipping 216 matching lines @@
     ASSERT_TRUE(CreateTestClients(&setup_constraints, &setup_constraints));
     LocalP2PTest();
     VerifyRenderedSize(640, 480);
   }
 
   PeerConnectionTestClient* CreateDtlsClientWithAlternateKey() {
     FakeConstraints setup_constraints;
     setup_constraints.AddMandatory(MediaConstraintsInterface::kEnableDtlsSrtp,
                                    true);
 
-    rtc::scoped_ptr<FakeDtlsIdentityStore> dtls_identity_store(
+    std::unique_ptr<FakeDtlsIdentityStore> dtls_identity_store(
         rtc::SSLStreamAdapter::HaveDtlsSrtp() ? new FakeDtlsIdentityStore()
                                               : nullptr);
     dtls_identity_store->use_alternate_key();
 
     // Make sure the new client is using a different certificate.
     return PeerConnectionTestClient::CreateClientWithDtlsIdentityStore(
         "New Peer: ", &setup_constraints, nullptr,
         std::move(dtls_identity_store), prefer_constraint_apis_,
         &worker_thread_);
   }
@@ skipping 31 matching lines @@
       PeerConnectionTestClient* client) {
     PeerConnectionTestClient* old = receiving_client_.release();
     receiving_client_.reset(client);
     return old;
   }
 
  private:
   // |worker_thread_| is used by both |initiating_client_| and
   // |receiving_client_|. Must be destroyed last.
   rtc::Thread worker_thread_;
-  rtc::scoped_ptr<rtc::PhysicalSocketServer> pss_;
-  rtc::scoped_ptr<rtc::VirtualSocketServer> ss_;
+  std::unique_ptr<rtc::PhysicalSocketServer> pss_;
+  std::unique_ptr<rtc::VirtualSocketServer> ss_;
   rtc::SocketServerScope ss_scope_;
-  rtc::scoped_ptr<PeerConnectionTestClient> initiating_client_;
-  rtc::scoped_ptr<PeerConnectionTestClient> receiving_client_;
+  std::unique_ptr<PeerConnectionTestClient> initiating_client_;
+  std::unique_ptr<PeerConnectionTestClient> receiving_client_;
   bool prefer_constraint_apis_ = true;
 };
 
 // Disable for TSan v2, see
 // https://code.google.com/p/webrtc/issues/detail?id=1205 for details.
 #if !defined(THREAD_SANITIZER)
 
 // This test sets up a Jsep call between two parties and test Dtmf.
 // TODO(holmer): Disabled due to sometimes crashing on buildbots.
 // See issue webrtc/2378.
@@ skipping 75 matching lines @@
 }
 
 // This test sets up a call transfer to a new caller with a different DTLS
 // fingerprint.
 TEST_F(P2PTestConductor, LocalP2PTestDtlsTransferCallee) {
   MAYBE_SKIP_TEST(rtc::SSLStreamAdapter::HaveDtlsSrtp);
   SetupAndVerifyDtlsCall();
 
   // Keeping the original peer around which will still send packets to the
   // receiving client. These SRTP packets will be dropped.
-  rtc::scoped_ptr<PeerConnectionTestClient> original_peer(
+  std::unique_ptr<PeerConnectionTestClient> original_peer(
       set_initializing_client(CreateDtlsClientWithAlternateKey()));
   original_peer->pc()->Close();
 
   SetSignalingReceivers();
   receiving_client()->SetExpectIceRestart(true);
   LocalP2PTest();
   VerifyRenderedSize(640, 480);
 }
 
 // This test sets up a non-bundle call and apply bundle during ICE restart. When
@@ skipping 17 matching lines @@
 }
 
 // This test sets up a call transfer to a new callee with a different DTLS
 // fingerprint.
 TEST_F(P2PTestConductor, LocalP2PTestDtlsTransferCaller) {
   MAYBE_SKIP_TEST(rtc::SSLStreamAdapter::HaveDtlsSrtp);
   SetupAndVerifyDtlsCall();
 
   // Keeping the original peer around which will still send packets to the
   // receiving client. These SRTP packets will be dropped.
-  rtc::scoped_ptr<PeerConnectionTestClient> original_peer(
+  std::unique_ptr<PeerConnectionTestClient> original_peer(
       set_receiving_client(CreateDtlsClientWithAlternateKey()));
   original_peer->pc()->Close();
 
   SetSignalingReceivers();
   initializing_client()->IceRestart();
   LocalP2PTest();
   VerifyRenderedSize(640, 480);
 }
 
 TEST_F(P2PTestConductor, LocalP2PTestCVO) {
@@ skipping 742 matching lines @@
   server.urls.push_back("turn:hostname2");
   servers.push_back(server);
   EXPECT_TRUE(webrtc::ParseIceServers(servers, &stun_servers_, &turn_servers_));
   EXPECT_EQ(2U, turn_servers_.size());
   EXPECT_NE(turn_servers_[0].priority, turn_servers_[1].priority);
 }
 
 #endif // if !defined(THREAD_SANITIZER)
 
 }  // namespace