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

webrtc/modules/audio_coding/neteq/nack_tracker.h

 /*
  *  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.
  */
 
-#ifndef WEBRTC_MODULES_AUDIO_CODING_NETEQ_NACK_H_
-#define WEBRTC_MODULES_AUDIO_CODING_NETEQ_NACK_H_
+#ifndef WEBRTC_MODULES_AUDIO_CODING_NETEQ_NACK_TRACKER_H_
+#define WEBRTC_MODULES_AUDIO_CODING_NETEQ_NACK_TRACKER_H_
 
 #include <vector>
 #include <map>
 
 #include "webrtc/base/gtest_prod_util.h"
 #include "webrtc/modules/audio_coding/include/audio_coding_module_typedefs.h"
 
 //
-// The Nack class keeps track of the lost packets, an estimate of time-to-play
-// for each packet is also given.
+// The NackTracker class keeps track of the lost packets, an estimate of
+// time-to-play for each packet is also given.
 //
 // Every time a packet is pushed into NetEq, LastReceivedPacket() has to be
 // called to update the NACK list.
 //
 // Every time 10ms audio is pulled from NetEq LastDecodedPacket() should be
 // called, and time-to-play is updated at that moment.
 //
 // If packet N is received, any packet prior to |N - NackThreshold| which is not
 // arrived is considered lost, and should be labeled as "missing" (the size of
 // the list might be limited and older packet eliminated from the list). Packets
 // |N - NackThreshold|, |N - NackThreshold + 1|, ..., |N - 1| are considered
 // "late." A "late" packet with sequence number K is changed to "missing" any
 // time a packet with sequence number newer than |K + NackList| is arrived.
 //
-// The Nack class has to know about the sample rate of the packets to compute
-// time-to-play. So sample rate should be set as soon as the first packet is
-// received. If there is a change in the receive codec (sender changes codec)
-// then Nack should be reset. This is because NetEQ would flush its buffer and
-// re-transmission is meaning less for old packet. Therefore, in that case,
-// after reset the sampling rate has to be updated.
+// The NackTracker class has to know about the sample rate of the packets to
+// compute time-to-play. So sample rate should be set as soon as the first
+// packet is received. If there is a change in the receive codec (sender changes
+// codec) then NackTracker should be reset. This is because NetEQ would flush
+// its buffer and re-transmission is meaning less for old packet. Therefore, in
+// that case, after reset the sampling rate has to be updated.
 //
 // Thread Safety
 // =============
 // Please note that this class in not thread safe. The class must be protected
 // if different APIs are called from different threads.
 //
 namespace webrtc {
 
-class Nack {
+class NackTracker {
  public:
   // A limit for the size of the NACK list.
   static const size_t kNackListSizeLimit = 500;  // 10 seconds for 20 ms frame
                                                  // packets.
   // Factory method.
-  static Nack* Create(int nack_threshold_packets);
+  static NackTracker* Create(int nack_threshold_packets);
 
-  ~Nack();
+  ~NackTracker();
 
   // Set a maximum for the size of the NACK list. If the last received packet
   // has sequence number of N, then NACK list will not contain any element
   // with sequence number earlier than N - |max_nack_list_size|.
   //
   // The largest maximum size is defined by |kNackListSizeLimit|
   void SetMaxNackListSize(size_t max_nack_list_size);
 
   // Set the sampling rate.
   //
@@ skipping 15 matching lines @@
   // than the given round-trip-time (in milliseconds).
   // Note: Late packets are not included.
   std::vector<uint16_t> GetNackList(int64_t round_trip_time_ms) const;
 
   // Reset to default values. The NACK list is cleared.
   // |nack_threshold_packets_| & |max_nack_list_size_| preserve their values.
   void Reset();
 
  private:
   // This test need to access the private method GetNackList().
-  FRIEND_TEST_ALL_PREFIXES(NackTest, EstimateTimestampAndTimeToPlay);
+  FRIEND_TEST_ALL_PREFIXES(NackTrackerTest, EstimateTimestampAndTimeToPlay);
 
   struct NackElement {
     NackElement(int64_t initial_time_to_play_ms,
                 uint32_t initial_timestamp,
                 bool missing)
         : time_to_play_ms(initial_time_to_play_ms),
           estimated_timestamp(initial_timestamp),
           is_missing(missing) {}
 
     // Estimated time (ms) left for this packet to be decoded. This estimate is
@@ skipping 17 matching lines @@
    public:
     bool operator()(uint16_t sequence_number_old,
                     uint16_t sequence_number_new) const {
       return IsNewerSequenceNumber(sequence_number_new, sequence_number_old);
     }
   };
 
   typedef std::map<uint16_t, NackElement, NackListCompare> NackList;
 
   // Constructor.
-  explicit Nack(int nack_threshold_packets);
+  explicit NackTracker(int nack_threshold_packets);
 
   // This API is used only for testing to assess whether time-to-play is
   // computed correctly.
   NackList GetNackList() const;
 
   // Given the |sequence_number_current_received_rtp| of currently received RTP,
   // recognize packets which are not arrive and add to the list.
   void AddToList(uint16_t sequence_number_current_received_rtp);
 
   // This function subtracts 10 ms of time-to-play for all packets in NACK list.
@@ skipping 54 matching lines @@
   // each pack is going to be played out.
   NackList nack_list_;
 
   // NACK list will not keep track of missing packets prior to
   // |sequence_num_last_received_rtp_| - |max_nack_list_size_|.
   size_t max_nack_list_size_;
 };
 
 }  // namespace webrtc
 
-#endif  // WEBRTC_MODULES_AUDIO_CODING_NETEQ_NACK_H_
+#endif  // WEBRTC_MODULES_AUDIO_CODING_NETEQ_NACK_TRACKER_H_