NetEq: Rename Nack to NackTracker to avoid name collisions in GN

webrtc/modules/audio_coding/neteq/nack_tracker.cc

Index: webrtc/modules/audio_coding/neteq/nack_tracker.cc
diff --git a/webrtc/modules/audio_coding/neteq/nack.cc b/webrtc/modules/audio_coding/neteq/nack_tracker.cc
similarity index 83%
rename from webrtc/modules/audio_coding/neteq/nack.cc
rename to webrtc/modules/audio_coding/neteq/nack_tracker.cc
index 011914b3d94d3f3d807ca32440145bd56b7bffd4..62cb2ec958af6b355bfb76325c101451988d5bfd 100644
--- a/webrtc/modules/audio_coding/neteq/nack.cc
+++ b/webrtc/modules/audio_coding/neteq/nack_tracker.cc
@@ -8,7 +8,7 @@
  *  be found in the AUTHORS file in the root of the source tree.
  */
 
-#include "webrtc/modules/audio_coding/neteq/nack.h"
+#include "webrtc/modules/audio_coding/neteq/nack_tracker.h"
 
 #include <assert.h>  // For assert.
 
@@ -26,7 +26,7 @@ const int kDefaultPacketSizeMs = 20;
 
 }  // namespace
 
-Nack::Nack(int nack_threshold_packets)
+NackTracker::NackTracker(int nack_threshold_packets)
     : nack_threshold_packets_(nack_threshold_packets),
       sequence_num_last_received_rtp_(0),
       timestamp_last_received_rtp_(0),
@@ -38,19 +38,19 @@ Nack::Nack(int nack_threshold_packets)
       samples_per_packet_(sample_rate_khz_ * kDefaultPacketSizeMs),
       max_nack_list_size_(kNackListSizeLimit) {}
 
-Nack::~Nack() = default;
+NackTracker::~NackTracker() = default;
 
-Nack* Nack::Create(int nack_threshold_packets) {
-  return new Nack(nack_threshold_packets);
+NackTracker* NackTracker::Create(int nack_threshold_packets) {
+  return new NackTracker(nack_threshold_packets);
 }
 
-void Nack::UpdateSampleRate(int sample_rate_hz) {
+void NackTracker::UpdateSampleRate(int sample_rate_hz) {
   assert(sample_rate_hz > 0);
   sample_rate_khz_ = sample_rate_hz / 1000;
 }
 
-void Nack::UpdateLastReceivedPacket(uint16_t sequence_number,
-                                    uint32_t timestamp) {
+void NackTracker::UpdateLastReceivedPacket(uint16_t sequence_number,
+                                           uint32_t timestamp) {
   // Just record the value of sequence number and timestamp if this is the
   // first packet.
   if (!any_rtp_received_) {
@@ -85,8 +85,9 @@ void Nack::UpdateLastReceivedPacket(uint16_t sequence_number,
   LimitNackListSize();
 }
 
-void Nack::UpdateSamplesPerPacket(uint16_t sequence_number_current_received_rtp,
-                                  uint32_t timestamp_current_received_rtp) {
+void NackTracker::UpdateSamplesPerPacket(
+    uint16_t sequence_number_current_received_rtp,
+    uint32_t timestamp_current_received_rtp) {
   uint32_t timestamp_increase =
       timestamp_current_received_rtp - timestamp_last_received_rtp_;
   uint16_t sequence_num_increase =
@@ -95,7 +96,7 @@ void Nack::UpdateSamplesPerPacket(uint16_t sequence_number_current_received_rtp,
   samples_per_packet_ = timestamp_increase / sequence_num_increase;
 }
 
-void Nack::UpdateList(uint16_t sequence_number_current_received_rtp) {
+void NackTracker::UpdateList(uint16_t sequence_number_current_received_rtp) {
   // Some of the packets which were considered late, now are considered missing.
   ChangeFromLateToMissing(sequence_number_current_received_rtp);
 
@@ -104,7 +105,7 @@ void Nack::UpdateList(uint16_t sequence_number_current_received_rtp) {
     AddToList(sequence_number_current_received_rtp);
 }
 
-void Nack::ChangeFromLateToMissing(
+void NackTracker::ChangeFromLateToMissing(
     uint16_t sequence_number_current_received_rtp) {
   NackList::const_iterator lower_bound =
       nack_list_.lower_bound(static_cast<uint16_t>(
@@ -114,12 +115,12 @@ void Nack::ChangeFromLateToMissing(
     it->second.is_missing = true;
 }
 
-uint32_t Nack::EstimateTimestamp(uint16_t sequence_num) {
+uint32_t NackTracker::EstimateTimestamp(uint16_t sequence_num) {
   uint16_t sequence_num_diff = sequence_num - sequence_num_last_received_rtp_;
   return sequence_num_diff * samples_per_packet_ + timestamp_last_received_rtp_;
 }
 
-void Nack::AddToList(uint16_t sequence_number_current_received_rtp) {
+void NackTracker::AddToList(uint16_t sequence_number_current_received_rtp) {
   assert(!any_rtp_decoded_ ||
          IsNewerSequenceNumber(sequence_number_current_received_rtp,
                                sequence_num_last_decoded_rtp_));
@@ -138,7 +139,7 @@ void Nack::AddToList(uint16_t sequence_number_current_received_rtp) {
   }
 }
 
-void Nack::UpdateEstimatedPlayoutTimeBy10ms() {
+void NackTracker::UpdateEstimatedPlayoutTimeBy10ms() {
   while (!nack_list_.empty() &&
          nack_list_.begin()->second.time_to_play_ms <= 10)
     nack_list_.erase(nack_list_.begin());
@@ -147,8 +148,8 @@ void Nack::UpdateEstimatedPlayoutTimeBy10ms() {
     it->second.time_to_play_ms -= 10;
 }
 
-void Nack::UpdateLastDecodedPacket(uint16_t sequence_number,
-                                   uint32_t timestamp) {
+void NackTracker::UpdateLastDecodedPacket(uint16_t sequence_number,
+                                          uint32_t timestamp) {
   if (IsNewerSequenceNumber(sequence_number, sequence_num_last_decoded_rtp_) ||
       !any_rtp_decoded_) {
     sequence_num_last_decoded_rtp_ = sequence_number;
@@ -177,11 +178,11 @@ void Nack::UpdateLastDecodedPacket(uint16_t sequence_number,
   any_rtp_decoded_ = true;
 }
 
-Nack::NackList Nack::GetNackList() const {
+NackTracker::NackList NackTracker::GetNackList() const {
   return nack_list_;
 }
 
-void Nack::Reset() {
+void NackTracker::Reset() {
   nack_list_.clear();
 
   sequence_num_last_received_rtp_ = 0;
@@ -194,29 +195,30 @@ void Nack::Reset() {
   samples_per_packet_ = sample_rate_khz_ * kDefaultPacketSizeMs;
 }
 
-void Nack::SetMaxNackListSize(size_t max_nack_list_size) {
+void NackTracker::SetMaxNackListSize(size_t max_nack_list_size) {
   RTC_CHECK_GT(max_nack_list_size, 0u);
   // Ugly hack to get around the problem of passing static consts by reference.
-  const size_t kNackListSizeLimitLocal = Nack::kNackListSizeLimit;
+  const size_t kNackListSizeLimitLocal = NackTracker::kNackListSizeLimit;
   RTC_CHECK_LE(max_nack_list_size, kNackListSizeLimitLocal);
 
   max_nack_list_size_ = max_nack_list_size;
   LimitNackListSize();
 }
 
-void Nack::LimitNackListSize() {
+void NackTracker::LimitNackListSize() {
   uint16_t limit = sequence_num_last_received_rtp_ -
                    static_cast<uint16_t>(max_nack_list_size_) - 1;
   nack_list_.erase(nack_list_.begin(), nack_list_.upper_bound(limit));
 }
 
-int64_t Nack::TimeToPlay(uint32_t timestamp) const {
+int64_t NackTracker::TimeToPlay(uint32_t timestamp) const {
   uint32_t timestamp_increase = timestamp - timestamp_last_decoded_rtp_;
   return timestamp_increase / sample_rate_khz_;
 }
 
 // We don't erase elements with time-to-play shorter than round-trip-time.
-std::vector<uint16_t> Nack::GetNackList(int64_t round_trip_time_ms) const {
+std::vector<uint16_t> NackTracker::GetNackList(
+    int64_t round_trip_time_ms) const {
   RTC_DCHECK_GE(round_trip_time_ms, 0);
   std::vector<uint16_t> sequence_numbers;
   for (NackList::const_iterator it = nack_list_.begin(); it != nack_list_.end();