Replace scoped_ptr with unique_ptr in webrtc/modules/audio_coding/neteq/

webrtc/modules/audio_coding/neteq/payload_splitter_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.
  */
 
 // Unit tests for PayloadSplitter class.
 
 #include "webrtc/modules/audio_coding/neteq/payload_splitter.h"
 
 #include <assert.h>
 
+#include <memory>
 #include <utility>  // pair
 
 #include "testing/gtest/include/gtest/gtest.h"
-#include "webrtc/base/scoped_ptr.h"
 #include "webrtc/modules/audio_coding/neteq/mock/mock_decoder_database.h"
 #include "webrtc/modules/audio_coding/neteq/packet.h"
 
 using ::testing::Return;
 using ::testing::ReturnNull;
 
 namespace webrtc {
 
 static const int kRedPayloadType = 100;
 static const size_t kPayloadLength = 10;
@@ skipping 333 matching lines @@
   PacketList packet_list;
   for (uint8_t i = 0; i < 6; ++i) {
     // Let the payload type be |i|, and the payload value 10 * |i|.
     packet_list.push_back(CreatePacket(i, kPayloadLength, 10 * i));
   }
 
   MockDecoderDatabase decoder_database;
   // Tell the mock decoder database to return DecoderInfo structs with different
   // codec types.
   // Use scoped pointers to avoid having to delete them later.
-  rtc::scoped_ptr<DecoderDatabase::DecoderInfo> info0(
+  std::unique_ptr<DecoderDatabase::DecoderInfo> info0(
       new DecoderDatabase::DecoderInfo(NetEqDecoder::kDecoderISAC, 16000, NULL,
                                        false));
   EXPECT_CALL(decoder_database, GetDecoderInfo(0))
       .WillRepeatedly(Return(info0.get()));
-  rtc::scoped_ptr<DecoderDatabase::DecoderInfo> info1(
+  std::unique_ptr<DecoderDatabase::DecoderInfo> info1(
       new DecoderDatabase::DecoderInfo(NetEqDecoder::kDecoderISACswb, 32000,
                                        NULL, false));
   EXPECT_CALL(decoder_database, GetDecoderInfo(1))
       .WillRepeatedly(Return(info1.get()));
-  rtc::scoped_ptr<DecoderDatabase::DecoderInfo> info2(
+  std::unique_ptr<DecoderDatabase::DecoderInfo> info2(
       new DecoderDatabase::DecoderInfo(NetEqDecoder::kDecoderRED, 8000, NULL,
                                        false));
   EXPECT_CALL(decoder_database, GetDecoderInfo(2))
       .WillRepeatedly(Return(info2.get()));
-  rtc::scoped_ptr<DecoderDatabase::DecoderInfo> info3(
+  std::unique_ptr<DecoderDatabase::DecoderInfo> info3(
       new DecoderDatabase::DecoderInfo(NetEqDecoder::kDecoderAVT, 8000, NULL,
                                        false));
   EXPECT_CALL(decoder_database, GetDecoderInfo(3))
       .WillRepeatedly(Return(info3.get()));
-  rtc::scoped_ptr<DecoderDatabase::DecoderInfo> info4(
+  std::unique_ptr<DecoderDatabase::DecoderInfo> info4(
       new DecoderDatabase::DecoderInfo(NetEqDecoder::kDecoderCNGnb, 8000, NULL,
                                        false));
   EXPECT_CALL(decoder_database, GetDecoderInfo(4))
       .WillRepeatedly(Return(info4.get()));
-  rtc::scoped_ptr<DecoderDatabase::DecoderInfo> info5(
+  std::unique_ptr<DecoderDatabase::DecoderInfo> info5(
       new DecoderDatabase::DecoderInfo(NetEqDecoder::kDecoderArbitrary, 8000,
                                        NULL, false));
   EXPECT_CALL(decoder_database, GetDecoderInfo(5))
       .WillRepeatedly(Return(info5.get()));
 
   PayloadSplitter splitter;
   EXPECT_EQ(0, splitter.SplitAudio(&packet_list, decoder_database));
   EXPECT_EQ(6u, packet_list.size());
 
   // Check that all payloads are intact.
@@ skipping 118 matching lines @@
     size_t payload_size_bytes = payload_size_ms * bytes_per_ms_;
     packet_list.push_back(CreatePacket(kPayloadType, payload_size_bytes,
                                        payload_size_ms));
   }
 
   MockDecoderDatabase decoder_database;
   // Tell the mock decoder database to return DecoderInfo structs with different
   // codec types.
   // Use scoped pointers to avoid having to delete them later.
   // (Sample rate is set to 8000 Hz, but does not matter.)
-  rtc::scoped_ptr<DecoderDatabase::DecoderInfo> info(
+  std::unique_ptr<DecoderDatabase::DecoderInfo> info(
       new DecoderDatabase::DecoderInfo(decoder_type_, 8000, NULL, false));
   EXPECT_CALL(decoder_database, GetDecoderInfo(kPayloadType))
       .WillRepeatedly(Return(info.get()));
 
   PayloadSplitter splitter;
   EXPECT_EQ(0, splitter.SplitAudio(&packet_list, decoder_database));
   // The payloads are expected to be split as follows:
   // 10 ms -> 10 ms
   // 20 ms -> 20 ms
   // 30 ms -> 30 ms
@@ skipping 66 matching lines @@
   // Fill payload with increasing integers {0, 1, 2, ...}.
   for (size_t i = 0; i < packet->payload_length; ++i) {
     packet->payload[i] = static_cast<uint8_t>(i);
   }
   packet_list.push_back(packet);
 
   MockDecoderDatabase decoder_database;
   // Tell the mock decoder database to return DecoderInfo structs with different
   // codec types.
   // Use scoped pointers to avoid having to delete them later.
-  rtc::scoped_ptr<DecoderDatabase::DecoderInfo> info(
+  std::unique_ptr<DecoderDatabase::DecoderInfo> info(
       new DecoderDatabase::DecoderInfo(NetEqDecoder::kDecoderILBC, 8000, NULL,
                                        false));
   EXPECT_CALL(decoder_database, GetDecoderInfo(kPayloadType))
       .WillRepeatedly(Return(info.get()));
 
   PayloadSplitter splitter;
   EXPECT_EQ(0, splitter.SplitAudio(&packet_list, decoder_database));
   EXPECT_EQ(num_frames_, packet_list.size());
 
   PacketList::iterator it = packet_list.begin();
@@ skipping 43 matching lines @@
 
 // Test too large payload size.
 TEST(IlbcPayloadSplitter, TooLargePayload) {
   PacketList packet_list;
   static const uint8_t kPayloadType = 17;  // Just a random number.
   size_t kPayloadLengthBytes = 950;
   Packet* packet = CreatePacket(kPayloadType, kPayloadLengthBytes, 0);
   packet_list.push_back(packet);
 
   MockDecoderDatabase decoder_database;
-  rtc::scoped_ptr<DecoderDatabase::DecoderInfo> info(
+  std::unique_ptr<DecoderDatabase::DecoderInfo> info(
       new DecoderDatabase::DecoderInfo(NetEqDecoder::kDecoderILBC, 8000, NULL,
                                        false));
   EXPECT_CALL(decoder_database, GetDecoderInfo(kPayloadType))
       .WillRepeatedly(Return(info.get()));
 
   PayloadSplitter splitter;
   EXPECT_EQ(PayloadSplitter::kTooLargePayload,
             splitter.SplitAudio(&packet_list, decoder_database));
   EXPECT_EQ(1u, packet_list.size());
 
@@ skipping 11 matching lines @@
 
 // Payload not an integer number of frames.
 TEST(IlbcPayloadSplitter, UnevenPayload) {
   PacketList packet_list;
   static const uint8_t kPayloadType = 17;  // Just a random number.
   size_t kPayloadLengthBytes = 39;  // Not an even number of frames.
   Packet* packet = CreatePacket(kPayloadType, kPayloadLengthBytes, 0);
   packet_list.push_back(packet);
 
   MockDecoderDatabase decoder_database;
-  rtc::scoped_ptr<DecoderDatabase::DecoderInfo> info(
+  std::unique_ptr<DecoderDatabase::DecoderInfo> info(
       new DecoderDatabase::DecoderInfo(NetEqDecoder::kDecoderILBC, 8000, NULL,
                                        false));
   EXPECT_CALL(decoder_database, GetDecoderInfo(kPayloadType))
       .WillRepeatedly(Return(info.get()));
 
   PayloadSplitter splitter;
   EXPECT_EQ(PayloadSplitter::kFrameSplitError,
             splitter.SplitAudio(&packet_list, decoder_database));
   EXPECT_EQ(1u, packet_list.size());
 
@@ skipping 121 matching lines @@
   EXPECT_EQ(kBaseTimestamp - kTimestampOffset, packet->header.timestamp);
   EXPECT_EQ(kPayloadLength, packet->payload_length);
   EXPECT_TRUE(packet->primary);
   EXPECT_EQ(packet->payload[3], 0);
   delete [] packet->payload;
   delete packet;
   packet_list.pop_front();
 }
 
 }  // namespace webrtc