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

webrtc/modules/audio_coding/neteq/nack_unittest.cc

 /*
  *  Copyright (c) 2013 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/modules/audio_coding/neteq/nack.h"
 
 #include <stdint.h>
 
 #include <algorithm>
+#include <memory>
 
 #include "testing/gtest/include/gtest/gtest.h"
-#include "webrtc/base/scoped_ptr.h"
 #include "webrtc/typedefs.h"
 #include "webrtc/modules/audio_coding/include/audio_coding_module_typedefs.h"
 
 namespace webrtc {
 namespace {
 
 const int kNackThreshold = 3;
 const int kSampleRateHz = 16000;
 const int kPacketSizeMs = 30;
 const uint32_t kTimestampIncrement = 480;  // 30 ms.
@@ skipping 19 matching lines @@
     }
     if (!seq_num_matched)
       return false;
   }
   return true;
 }
 
 }  // namespace
 
 TEST(NackTest, EmptyListWhenNoPacketLoss) {
-  rtc::scoped_ptr<Nack> nack(Nack::Create(kNackThreshold));
+  std::unique_ptr<Nack> nack(Nack::Create(kNackThreshold));
   nack->UpdateSampleRate(kSampleRateHz);
 
   int seq_num = 1;
   uint32_t timestamp = 0;
 
   std::vector<uint16_t> nack_list;
   for (int n = 0; n < 100; n++) {
     nack->UpdateLastReceivedPacket(seq_num, timestamp);
     nack_list = nack->GetNackList(kShortRoundTripTimeMs);
     seq_num++;
     timestamp += kTimestampIncrement;
     nack_list = nack->GetNackList(kShortRoundTripTimeMs);
     EXPECT_TRUE(nack_list.empty());
   }
 }
 
 TEST(NackTest, NoNackIfReorderWithinNackThreshold) {
-  rtc::scoped_ptr<Nack> nack(Nack::Create(kNackThreshold));
+  std::unique_ptr<Nack> nack(Nack::Create(kNackThreshold));
   nack->UpdateSampleRate(kSampleRateHz);
 
   int seq_num = 1;
   uint32_t timestamp = 0;
   std::vector<uint16_t> nack_list;
 
   nack->UpdateLastReceivedPacket(seq_num, timestamp);
   nack_list = nack->GetNackList(kShortRoundTripTimeMs);
   EXPECT_TRUE(nack_list.empty());
   int num_late_packets = kNackThreshold + 1;
 
   // Push in reverse order
   while (num_late_packets > 0) {
     nack->UpdateLastReceivedPacket(
         seq_num + num_late_packets,
         timestamp + num_late_packets * kTimestampIncrement);
     nack_list = nack->GetNackList(kShortRoundTripTimeMs);
     EXPECT_TRUE(nack_list.empty());
     num_late_packets--;
   }
 }
 
 TEST(NackTest, LatePacketsMovedToNackThenNackListDoesNotChange) {
   const uint16_t kSequenceNumberLostPackets[] = {2, 3, 4, 5, 6, 7, 8, 9};
   static const int kNumAllLostPackets = sizeof(kSequenceNumberLostPackets) /
                                         sizeof(kSequenceNumberLostPackets[0]);
 
   for (int k = 0; k < 2; k++) {  // Two iteration with/without wrap around.
-    rtc::scoped_ptr<Nack> nack(Nack::Create(kNackThreshold));
+    std::unique_ptr<Nack> nack(Nack::Create(kNackThreshold));
     nack->UpdateSampleRate(kSampleRateHz);
 
     uint16_t sequence_num_lost_packets[kNumAllLostPackets];
     for (int n = 0; n < kNumAllLostPackets; n++) {
       sequence_num_lost_packets[n] =
           kSequenceNumberLostPackets[n] +
           k * 65531;  // Have wrap around in sequence numbers for |k == 1|.
     }
     uint16_t seq_num = sequence_num_lost_packets[0] - 1;
 
@@ skipping 28 matching lines @@
     }
   }
 }
 
 TEST(NackTest, ArrivedPacketsAreRemovedFromNackList) {
   const uint16_t kSequenceNumberLostPackets[] = {2, 3, 4, 5, 6, 7, 8, 9};
   static const int kNumAllLostPackets = sizeof(kSequenceNumberLostPackets) /
                                         sizeof(kSequenceNumberLostPackets[0]);
 
   for (int k = 0; k < 2; ++k) {  // Two iteration with/without wrap around.
-    rtc::scoped_ptr<Nack> nack(Nack::Create(kNackThreshold));
+    std::unique_ptr<Nack> nack(Nack::Create(kNackThreshold));
     nack->UpdateSampleRate(kSampleRateHz);
 
     uint16_t sequence_num_lost_packets[kNumAllLostPackets];
     for (int n = 0; n < kNumAllLostPackets; ++n) {
       sequence_num_lost_packets[n] = kSequenceNumberLostPackets[n] +
                                      k * 65531;  // Wrap around for |k == 1|.
     }
 
     uint16_t seq_num = sequence_num_lost_packets[0] - 1;
     uint32_t timestamp = 0;
@@ skipping 41 matching lines @@
 
 // Assess if estimation of timestamps and time-to-play is correct. Introduce all
 // combinations that timestamps and sequence numbers might have wrap around.
 TEST(NackTest, EstimateTimestampAndTimeToPlay) {
   const uint16_t kLostPackets[] = {2, 3,  4,  5,  6,  7,  8,
                                    9, 10, 11, 12, 13, 14, 15};
   static const int kNumAllLostPackets =
       sizeof(kLostPackets) / sizeof(kLostPackets[0]);
 
   for (int k = 0; k < 4; ++k) {
-    rtc::scoped_ptr<Nack> nack(Nack::Create(kNackThreshold));
+    std::unique_ptr<Nack> nack(Nack::Create(kNackThreshold));
     nack->UpdateSampleRate(kSampleRateHz);
 
     // Sequence number wrap around if |k| is 2 or 3;
     int seq_num_offset = (k < 2) ? 0 : 65531;
 
     // Timestamp wrap around if |k| is 1 or 3.
     uint32_t timestamp_offset =
         (k & 0x1) ? static_cast<uint32_t>(0xffffffff) - 6 : 0;
 
     uint32_t timestamp_lost_packets[kNumAllLostPackets];
@@ skipping 50 matching lines @@
       int index = seq_num - kLostPackets[0];
       EXPECT_EQ((index + 2) * kPacketSizeMs - 10, it->second.time_to_play_ms);
       ++it;
     }
   }
 }
 
 TEST(NackTest, MissingPacketsPriorToLastDecodedRtpShouldNotBeInNackList) {
   for (int m = 0; m < 2; ++m) {
     uint16_t seq_num_offset = (m == 0) ? 0 : 65531;  // Wrap around if |m| is 1.
-    rtc::scoped_ptr<Nack> nack(Nack::Create(kNackThreshold));
+    std::unique_ptr<Nack> nack(Nack::Create(kNackThreshold));
     nack->UpdateSampleRate(kSampleRateHz);
 
     // Two consecutive packets to have a correct estimate of timestamp increase.
     uint16_t seq_num = 0;
     nack->UpdateLastReceivedPacket(seq_num_offset + seq_num,
                                    seq_num * kTimestampIncrement);
     seq_num++;
     nack->UpdateLastReceivedPacket(seq_num_offset + seq_num,
                                    seq_num * kTimestampIncrement);
 
@@ skipping 30 matching lines @@
       seq_num++;
       nack->UpdateLastReceivedPacket(seq_num_offset + seq_num,
                                      seq_num * kTimestampIncrement);
       nack_list = nack->GetNackList(kShortRoundTripTimeMs);
       EXPECT_TRUE(nack_list.empty());
     }
   }
 }
 
 TEST(NackTest, Reset) {
-  rtc::scoped_ptr<Nack> nack(Nack::Create(kNackThreshold));
+  std::unique_ptr<Nack> nack(Nack::Create(kNackThreshold));
   nack->UpdateSampleRate(kSampleRateHz);
 
   // Two consecutive packets to have a correct estimate of timestamp increase.
   uint16_t seq_num = 0;
   nack->UpdateLastReceivedPacket(seq_num, seq_num * kTimestampIncrement);
   seq_num++;
   nack->UpdateLastReceivedPacket(seq_num, seq_num * kTimestampIncrement);
 
   // Skip 10 packets (larger than NACK threshold).
   const int kNumLostPackets = 10;
   seq_num += kNumLostPackets + 1;
   nack->UpdateLastReceivedPacket(seq_num, seq_num * kTimestampIncrement);
 
   const size_t kExpectedListSize = kNumLostPackets - kNackThreshold;
   std::vector<uint16_t> nack_list = nack->GetNackList(kShortRoundTripTimeMs);
   EXPECT_EQ(kExpectedListSize, nack_list.size());
 
   nack->Reset();
   nack_list = nack->GetNackList(kShortRoundTripTimeMs);
   EXPECT_TRUE(nack_list.empty());
 }
 
 TEST(NackTest, ListSizeAppliedFromBeginning) {
   const size_t kNackListSize = 10;
   for (int m = 0; m < 2; ++m) {
     uint16_t seq_num_offset = (m == 0) ? 0 : 65525;  // Wrap around if |m| is 1.
-    rtc::scoped_ptr<Nack> nack(Nack::Create(kNackThreshold));
+    std::unique_ptr<Nack> nack(Nack::Create(kNackThreshold));
     nack->UpdateSampleRate(kSampleRateHz);
     nack->SetMaxNackListSize(kNackListSize);
 
     uint16_t seq_num = seq_num_offset;
     uint32_t timestamp = 0x12345678;
     nack->UpdateLastReceivedPacket(seq_num, timestamp);
 
     // Packet lost more than NACK-list size limit.
     uint16_t num_lost_packets = kNackThreshold + kNackListSize + 5;
 
     seq_num += num_lost_packets + 1;
     timestamp += (num_lost_packets + 1) * kTimestampIncrement;
     nack->UpdateLastReceivedPacket(seq_num, timestamp);
 
     std::vector<uint16_t> nack_list = nack->GetNackList(kShortRoundTripTimeMs);
     EXPECT_EQ(kNackListSize - kNackThreshold, nack_list.size());
   }
 }
 
 TEST(NackTest, ChangeOfListSizeAppliedAndOldElementsRemoved) {
   const size_t kNackListSize = 10;
   for (int m = 0; m < 2; ++m) {
     uint16_t seq_num_offset = (m == 0) ? 0 : 65525;  // Wrap around if |m| is 1.
-    rtc::scoped_ptr<Nack> nack(Nack::Create(kNackThreshold));
+    std::unique_ptr<Nack> nack(Nack::Create(kNackThreshold));
     nack->UpdateSampleRate(kSampleRateHz);
 
     uint16_t seq_num = seq_num_offset;
     uint32_t timestamp = 0x87654321;
     nack->UpdateLastReceivedPacket(seq_num, timestamp);
 
     // Packet lost more than NACK-list size limit.
     uint16_t num_lost_packets = kNackThreshold + kNackListSize + 5;
 
-    rtc::scoped_ptr<uint16_t[]> seq_num_lost(new uint16_t[num_lost_packets]);
+    std::unique_ptr<uint16_t[]> seq_num_lost(new uint16_t[num_lost_packets]);
     for (int n = 0; n < num_lost_packets; ++n) {
       seq_num_lost[n] = ++seq_num;
     }
 
     ++seq_num;
     timestamp += (num_lost_packets + 1) * kTimestampIncrement;
     nack->UpdateLastReceivedPacket(seq_num, timestamp);
     size_t expected_size = num_lost_packets - kNackThreshold;
 
     std::vector<uint16_t> nack_list = nack->GetNackList(kShortRoundTripTimeMs);
@@ skipping 35 matching lines @@
     ++seq_num;
     timestamp += kTimestampIncrement;
     nack->UpdateLastReceivedPacket(seq_num, timestamp);
     nack_list = nack->GetNackList(kShortRoundTripTimeMs);
     EXPECT_TRUE(nack_list.empty());
   }
 }
 
 TEST(NackTest, RoudTripTimeIsApplied) {
   const int kNackListSize = 200;
-  rtc::scoped_ptr<Nack> nack(Nack::Create(kNackThreshold));
+  std::unique_ptr<Nack> nack(Nack::Create(kNackThreshold));
   nack->UpdateSampleRate(kSampleRateHz);
   nack->SetMaxNackListSize(kNackListSize);
 
   uint16_t seq_num = 0;
   uint32_t timestamp = 0x87654321;
   nack->UpdateLastReceivedPacket(seq_num, timestamp);
 
   // Packet lost more than NACK-list size limit.
   uint16_t kNumLostPackets = kNackThreshold + 5;
 
   seq_num += (1 + kNumLostPackets);
   timestamp += (1 + kNumLostPackets) * kTimestampIncrement;
   nack->UpdateLastReceivedPacket(seq_num, timestamp);
 
   // Expected time-to-play are:
   // kPacketSizeMs - 10, 2*kPacketSizeMs - 10, 3*kPacketSizeMs - 10, ...
   //
   // sequence number:  1,  2,  3,   4,   5
   // time-to-play:    20, 50, 80, 110, 140
   //
   std::vector<uint16_t> nack_list = nack->GetNackList(100);
   ASSERT_EQ(2u, nack_list.size());
   EXPECT_EQ(4, nack_list[0]);
   EXPECT_EQ(5, nack_list[1]);
 }
 
 }  // namespace webrtc