Replace scoped_ptr with unique_ptr in webrtc/media/

webrtc/media/engine/webrtcvoiceengine_unittest.cc

 /*
  *  Copyright (c) 2008 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 <memory>
+
 #include "webrtc/pc/channel.h"
 #include "webrtc/base/arraysize.h"
 #include "webrtc/base/byteorder.h"
 #include "webrtc/base/gunit.h"
 #include "webrtc/call.h"
 #include "webrtc/p2p/base/faketransportcontroller.h"
 #include "webrtc/test/field_trial.h"
 #include "webrtc/media/base/constants.h"
 #include "webrtc/media/base/fakemediaengine.h"
 #include "webrtc/media/base/fakenetworkinterface.h"
@@ skipping 2754 matching lines @@
   webrtc::AgcConfig config = {0};
   EXPECT_EQ(0, voe_.GetAgcConfig(config));
   EXPECT_EQ(set_config.targetLeveldBOv, config.targetLeveldBOv);
   EXPECT_EQ(set_config.digitalCompressionGaindB,
             config.digitalCompressionGaindB);
   EXPECT_EQ(set_config.limiterEnable, config.limiterEnable);
 }
 
 TEST_F(WebRtcVoiceEngineTestFake, SetOptionOverridesViaChannels) {
   EXPECT_TRUE(SetupEngineWithSendStream());
-  rtc::scoped_ptr<cricket::WebRtcVoiceMediaChannel> channel1(
+  std::unique_ptr<cricket::WebRtcVoiceMediaChannel> channel1(
       static_cast<cricket::WebRtcVoiceMediaChannel*>(engine_.CreateChannel(
           &call_, cricket::MediaConfig(), cricket::AudioOptions())));
-  rtc::scoped_ptr<cricket::WebRtcVoiceMediaChannel> channel2(
+  std::unique_ptr<cricket::WebRtcVoiceMediaChannel> channel2(
       static_cast<cricket::WebRtcVoiceMediaChannel*>(engine_.CreateChannel(
           &call_, cricket::MediaConfig(), cricket::AudioOptions())));
 
   // Have to add a stream to make SetSend work.
   cricket::StreamParams stream1;
   stream1.ssrcs.push_back(1);
   channel1->AddSendStream(stream1);
   cricket::StreamParams stream2;
   stream2.ssrcs.push_back(2);
   channel2->AddSendStream(stream2);
@@ skipping 79 matching lines @@
   EXPECT_TRUE(ec_enabled);
   EXPECT_FALSE(agc_enabled);
   EXPECT_FALSE(ns_enabled);
 }
 
 // This test verifies DSCP settings are properly applied on voice media channel.
 TEST_F(WebRtcVoiceEngineTestFake, TestSetDscpOptions) {
   EXPECT_TRUE(SetupEngineWithSendStream());
   cricket::FakeNetworkInterface network_interface;
   cricket::MediaConfig config;
-  rtc::scoped_ptr<cricket::VoiceMediaChannel> channel;
+  std::unique_ptr<cricket::VoiceMediaChannel> channel;
 
   channel.reset(engine_.CreateChannel(&call_, config, cricket::AudioOptions()));
   channel->SetInterface(&network_interface);
   // Default value when DSCP is disabled should be DSCP_DEFAULT.
   EXPECT_EQ(rtc::DSCP_DEFAULT, network_interface.dscp());
 
   config.enable_dscp = true;
   channel.reset(engine_.CreateChannel(&call_, config, cricket::AudioOptions()));
   channel->SetInterface(&network_interface);
   EXPECT_EQ(rtc::DSCP_EF, network_interface.dscp());
@@ skipping 207 matching lines @@
   // So we force the |recv_ch| to associate with a non-default channel.
   EXPECT_EQ(0, voe_.AssociateSendChannel(recv_ch, send_ch));
   EXPECT_EQ(voe_.GetAssociateSendChannel(recv_ch), send_ch);
 
   EXPECT_TRUE(channel_->RemoveSendStream(2));
   EXPECT_EQ(voe_.GetAssociateSendChannel(recv_ch), -1);
 }
 
 TEST_F(WebRtcVoiceEngineTestFake, SetRawAudioSink) {
   EXPECT_TRUE(SetupEngine());
-  rtc::scoped_ptr<FakeAudioSink> fake_sink_1(new FakeAudioSink());
-  rtc::scoped_ptr<FakeAudioSink> fake_sink_2(new FakeAudioSink());
+  std::unique_ptr<FakeAudioSink> fake_sink_1(new FakeAudioSink());
+  std::unique_ptr<FakeAudioSink> fake_sink_2(new FakeAudioSink());
 
   // Setting the sink before a recv stream exists should do nothing.
   channel_->SetRawAudioSink(kSsrc1, std::move(fake_sink_1));
   EXPECT_TRUE(
       channel_->AddRecvStream(cricket::StreamParams::CreateLegacy(kSsrc1)));
   EXPECT_EQ(nullptr, GetRecvStream(kSsrc1).sink());
 
   // Now try actually setting the sink.
   channel_->SetRawAudioSink(kSsrc1, std::move(fake_sink_2));
   EXPECT_NE(nullptr, GetRecvStream(kSsrc1).sink());
 
   // Now try resetting it.
   channel_->SetRawAudioSink(kSsrc1, nullptr);
   EXPECT_EQ(nullptr, GetRecvStream(kSsrc1).sink());
 }
 
 TEST_F(WebRtcVoiceEngineTestFake, SetRawAudioSinkDefaultRecvStream) {
   EXPECT_TRUE(SetupEngine());
-  rtc::scoped_ptr<FakeAudioSink> fake_sink_1(new FakeAudioSink());
-  rtc::scoped_ptr<FakeAudioSink> fake_sink_2(new FakeAudioSink());
+  std::unique_ptr<FakeAudioSink> fake_sink_1(new FakeAudioSink());
+  std::unique_ptr<FakeAudioSink> fake_sink_2(new FakeAudioSink());
 
   // Should be able to set a default sink even when no stream exists.
   channel_->SetRawAudioSink(0, std::move(fake_sink_1));
 
   // Create default channel and ensure it's assigned the default sink.
   DeliverPacket(kPcmuFrame, sizeof(kPcmuFrame));
   EXPECT_NE(nullptr, GetRecvStream(0x01).sink());
 
   // Try resetting the default sink.
   channel_->SetRawAudioSink(0, nullptr);
   EXPECT_EQ(nullptr, GetRecvStream(0x01).sink());
 
   // Try setting the default sink while the default stream exists.
   channel_->SetRawAudioSink(0, std::move(fake_sink_2));
   EXPECT_NE(nullptr, GetRecvStream(0x01).sink());
 
   // If we remove and add a default stream, it should get the same sink.
   EXPECT_TRUE(channel_->RemoveRecvStream(0x01));
   DeliverPacket(kPcmuFrame, sizeof(kPcmuFrame));
   EXPECT_NE(nullptr, GetRecvStream(0x01).sink());
 }
 
 // Tests that the library initializes and shuts down properly.
 TEST(WebRtcVoiceEngineTest, StartupShutdown) {
   cricket::WebRtcVoiceEngine engine;
   EXPECT_TRUE(engine.Init(rtc::Thread::Current()));
-  rtc::scoped_ptr<webrtc::Call> call(
+  std::unique_ptr<webrtc::Call> call(
       webrtc::Call::Create(webrtc::Call::Config()));
   cricket::VoiceMediaChannel* channel = engine.CreateChannel(
       call.get(), cricket::MediaConfig(), cricket::AudioOptions());
   EXPECT_TRUE(channel != nullptr);
   delete channel;
   engine.Terminate();
 
   // Reinit to catch regression where VoiceEngineObserver reference is lost
   EXPECT_TRUE(engine.Init(rtc::Thread::Current()));
   engine.Terminate();
@@ skipping 81 matching lines @@
       EXPECT_EQ("1", it->params.find("useinbandfec")->second);
     }
   }
   engine.Terminate();
 }
 
 // Tests that VoE supports at least 32 channels
 TEST(WebRtcVoiceEngineTest, Has32Channels) {
   cricket::WebRtcVoiceEngine engine;
   EXPECT_TRUE(engine.Init(rtc::Thread::Current()));
-  rtc::scoped_ptr<webrtc::Call> call(
+  std::unique_ptr<webrtc::Call> call(
       webrtc::Call::Create(webrtc::Call::Config()));
 
   cricket::VoiceMediaChannel* channels[32];
   int num_channels = 0;
   while (num_channels < arraysize(channels)) {
     cricket::VoiceMediaChannel* channel = engine.CreateChannel(
         call.get(), cricket::MediaConfig(), cricket::AudioOptions());
     if (!channel)
       break;
     channels[num_channels++] = channel;
   }
 
   int expected = arraysize(channels);
   EXPECT_EQ(expected, num_channels);
 
   while (num_channels > 0) {
     delete channels[--num_channels];
   }
   engine.Terminate();
 }
 
 // Test that we set our preferred codecs properly.
 TEST(WebRtcVoiceEngineTest, SetRecvCodecs) {
   cricket::WebRtcVoiceEngine engine;
   EXPECT_TRUE(engine.Init(rtc::Thread::Current()));
-  rtc::scoped_ptr<webrtc::Call> call(
+  std::unique_ptr<webrtc::Call> call(
       webrtc::Call::Create(webrtc::Call::Config()));
   cricket::WebRtcVoiceMediaChannel channel(&engine, cricket::MediaConfig(),
                                            cricket::AudioOptions(), call.get());
   cricket::AudioRecvParameters parameters;
   parameters.codecs = engine.codecs();
   EXPECT_TRUE(channel.SetRecvParameters(parameters));
 }