Replace scoped_ptr with unique_ptr in webrtc/media/

webrtc/media/base/rtpdataengine_unittest.cc

 /*
  *  Copyright (c) 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 <memory>
 #include <string>
 
 #include "webrtc/base/buffer.h"
 #include "webrtc/base/gunit.h"
 #include "webrtc/base/helpers.h"
-#include "webrtc/base/scoped_ptr.h"
 #include "webrtc/base/ssladapter.h"
 #include "webrtc/base/timing.h"
 #include "webrtc/media/base/constants.h"
 #include "webrtc/media/base/fakenetworkinterface.h"
 #include "webrtc/media/base/rtpdataengine.h"
 #include "webrtc/media/base/rtputils.h"
 
 class FakeTiming : public rtc::Timing {
  public:
   FakeTiming() : now_(0.0) {}
@@ skipping 90 matching lines @@
   cricket::ReceiveDataParams GetReceivedDataParams() {
     return receiver_->last_received_data_params();
   }
 
   bool HasSentData(int count) {
     return (iface_->NumRtpPackets() > count);
   }
 
   std::string GetSentData(int index) {
     // Assume RTP header of length 12
-    rtc::scoped_ptr<const rtc::Buffer> packet(
+    std::unique_ptr<const rtc::Buffer> packet(
         iface_->GetRtpPacket(index));
     if (packet->size() > 12) {
       return std::string(packet->data<char>() + 12, packet->size() - 12);
     } else {
       return "";
     }
   }
 
   cricket::RtpHeader GetSentDataHeader(int index) {
-    rtc::scoped_ptr<const rtc::Buffer> packet(
+    std::unique_ptr<const rtc::Buffer> packet(
         iface_->GetRtpPacket(index));
     cricket::RtpHeader header;
     GetRtpHeader(packet->data(), packet->size(), &header);
     return header;
   }
 
  private:
-  rtc::scoped_ptr<cricket::RtpDataEngine> dme_;
+  std::unique_ptr<cricket::RtpDataEngine> dme_;
   // Timing passed into dme_.  Owned by dme_;
   FakeTiming* timing_;
-  rtc::scoped_ptr<cricket::FakeNetworkInterface> iface_;
-  rtc::scoped_ptr<FakeDataReceiver> receiver_;
+  std::unique_ptr<cricket::FakeNetworkInterface> iface_;
+  std::unique_ptr<FakeDataReceiver> receiver_;
 };
 
 TEST_F(RtpDataMediaChannelTest, SetUnknownCodecs) {
-  rtc::scoped_ptr<cricket::RtpDataMediaChannel> dmc(CreateChannel());
+  std::unique_ptr<cricket::RtpDataMediaChannel> dmc(CreateChannel());
 
   cricket::DataCodec known_codec;
   known_codec.id = 103;
   known_codec.name = "google-data";
   cricket::DataCodec unknown_codec;
   unknown_codec.id = 104;
   unknown_codec.name = "unknown-data";
 
   cricket::DataSendParameters send_parameters_known;
   send_parameters_known.codecs.push_back(known_codec);
@@ skipping 14 matching lines @@
 
   EXPECT_TRUE(dmc->SetSendParameters(send_parameters_known));
   EXPECT_FALSE(dmc->SetSendParameters(send_parameters_unknown));
   EXPECT_TRUE(dmc->SetSendParameters(send_parameters_mixed));
   EXPECT_TRUE(dmc->SetRecvParameters(recv_parameters_known));
   EXPECT_FALSE(dmc->SetRecvParameters(recv_parameters_unknown));
   EXPECT_FALSE(dmc->SetRecvParameters(recv_parameters_mixed));
 }
 
 TEST_F(RtpDataMediaChannelTest, AddRemoveSendStream) {
-  rtc::scoped_ptr<cricket::RtpDataMediaChannel> dmc(CreateChannel());
+  std::unique_ptr<cricket::RtpDataMediaChannel> dmc(CreateChannel());
 
   cricket::StreamParams stream1;
   stream1.add_ssrc(41);
   EXPECT_TRUE(dmc->AddSendStream(stream1));
   cricket::StreamParams stream2;
   stream2.add_ssrc(42);
   EXPECT_TRUE(dmc->AddSendStream(stream2));
 
   EXPECT_TRUE(dmc->RemoveSendStream(41));
   EXPECT_TRUE(dmc->RemoveSendStream(42));
   EXPECT_FALSE(dmc->RemoveSendStream(43));
 }
 
 TEST_F(RtpDataMediaChannelTest, AddRemoveRecvStream) {
-  rtc::scoped_ptr<cricket::RtpDataMediaChannel> dmc(CreateChannel());
+  std::unique_ptr<cricket::RtpDataMediaChannel> dmc(CreateChannel());
 
   cricket::StreamParams stream1;
   stream1.add_ssrc(41);
   EXPECT_TRUE(dmc->AddRecvStream(stream1));
   cricket::StreamParams stream2;
   stream2.add_ssrc(42);
   EXPECT_TRUE(dmc->AddRecvStream(stream2));
   EXPECT_FALSE(dmc->AddRecvStream(stream2));
 
   EXPECT_TRUE(dmc->RemoveRecvStream(41));
   EXPECT_TRUE(dmc->RemoveRecvStream(42));
 }
 
 TEST_F(RtpDataMediaChannelTest, SendData) {
-  rtc::scoped_ptr<cricket::RtpDataMediaChannel> dmc(CreateChannel());
+  std::unique_ptr<cricket::RtpDataMediaChannel> dmc(CreateChannel());
 
   cricket::SendDataParams params;
   params.ssrc = 42;
   unsigned char data[] = "food";
   rtc::Buffer payload(data, 4);
   unsigned char padded_data[] = {
     0x00, 0x00, 0x00, 0x00,
     'f', 'o', 'o', 'd',
   };
   cricket::SendDataResult result;
@@ skipping 57 matching lines @@
   EXPECT_EQ(header1.ssrc, 42U);
   EXPECT_EQ(header1.payload_type, 103);
   EXPECT_EQ(static_cast<uint16_t>(header0.seq_num + 1),
             static_cast<uint16_t>(header1.seq_num));
   EXPECT_EQ(header0.timestamp + 180000, header1.timestamp);
 }
 
 TEST_F(RtpDataMediaChannelTest, SendDataMultipleClocks) {
   // Timings owned by RtpDataEngines.
   FakeTiming* timing1 = new FakeTiming();
-  rtc::scoped_ptr<cricket::RtpDataEngine> dme1(CreateEngine(timing1));
-  rtc::scoped_ptr<cricket::RtpDataMediaChannel> dmc1(
+  std::unique_ptr<cricket::RtpDataEngine> dme1(CreateEngine(timing1));
+  std::unique_ptr<cricket::RtpDataMediaChannel> dmc1(
       CreateChannel(dme1.get()));
   FakeTiming* timing2 = new FakeTiming();
-  rtc::scoped_ptr<cricket::RtpDataEngine> dme2(CreateEngine(timing2));
-  rtc::scoped_ptr<cricket::RtpDataMediaChannel> dmc2(
+  std::unique_ptr<cricket::RtpDataEngine> dme2(CreateEngine(timing2));
+  std::unique_ptr<cricket::RtpDataMediaChannel> dmc2(
       CreateChannel(dme2.get()));
 
   ASSERT_TRUE(dmc1->SetSend(true));
   ASSERT_TRUE(dmc2->SetSend(true));
 
   cricket::StreamParams stream1;
   stream1.add_ssrc(41);
   ASSERT_TRUE(dmc1->AddSendStream(stream1));
   cricket::StreamParams stream2;
   stream2.add_ssrc(42);
@@ skipping 35 matching lines @@
 
   EXPECT_EQ(static_cast<uint16_t>(header1a.seq_num + 1),
             static_cast<uint16_t>(header1b.seq_num));
   EXPECT_EQ(header1a.timestamp + 90000, header1b.timestamp);
   EXPECT_EQ(static_cast<uint16_t>(header2a.seq_num + 1),
             static_cast<uint16_t>(header2b.seq_num));
   EXPECT_EQ(header2a.timestamp + 180000, header2b.timestamp);
 }
 
 TEST_F(RtpDataMediaChannelTest, SendDataRate) {
-  rtc::scoped_ptr<cricket::RtpDataMediaChannel> dmc(CreateChannel());
+  std::unique_ptr<cricket::RtpDataMediaChannel> dmc(CreateChannel());
 
   ASSERT_TRUE(dmc->SetSend(true));
 
   cricket::DataCodec codec;
   codec.id = 103;
   codec.name = cricket::kGoogleRtpDataCodecName;
   cricket::DataSendParameters parameters;
   parameters.codecs.push_back(codec);
   ASSERT_TRUE(dmc->SetSendParameters(parameters));
 
@@ skipping 37 matching lines @@
 
 TEST_F(RtpDataMediaChannelTest, ReceiveData) {
   // PT= 103, SN=2, TS=3, SSRC = 4, data = "abcde"
   unsigned char data[] = {
     0x80, 0x67, 0x00, 0x02, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x2A,
     0x00, 0x00, 0x00, 0x00,
     'a', 'b', 'c', 'd', 'e'
   };
   rtc::Buffer packet(data, sizeof(data));
 
-  rtc::scoped_ptr<cricket::RtpDataMediaChannel> dmc(CreateChannel());
+  std::unique_ptr<cricket::RtpDataMediaChannel> dmc(CreateChannel());
 
   // SetReceived not called.
   dmc->OnPacketReceived(&packet, rtc::PacketTime());
   EXPECT_FALSE(HasReceivedData());
 
   dmc->SetReceive(true);
 
   // Unknown payload id
   dmc->OnPacketReceived(&packet, rtc::PacketTime());
   EXPECT_FALSE(HasReceivedData());
@@ skipping 19 matching lines @@
   EXPECT_EQ("abcde", GetReceivedData());
   EXPECT_EQ(5U, GetReceivedDataLen());
 }
 
 TEST_F(RtpDataMediaChannelTest, InvalidRtpPackets) {
   unsigned char data[] = {
     0x80, 0x65, 0x00, 0x02
   };
   rtc::Buffer packet(data, sizeof(data));
 
-  rtc::scoped_ptr<cricket::RtpDataMediaChannel> dmc(CreateChannel());
+  std::unique_ptr<cricket::RtpDataMediaChannel> dmc(CreateChannel());
 
   // Too short
   dmc->OnPacketReceived(&packet, rtc::PacketTime());
   EXPECT_FALSE(HasReceivedData());
 }