Remove duplicate-handling logic from PacedSender

webrtc/modules/pacing/paced_sender.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 "webrtc/modules/pacing/paced_sender.h"
 
 #include <algorithm>
-#include <map>
 #include <queue>
-#include <set>
 #include <vector>
 
 #include "webrtc/base/checks.h"
 #include "webrtc/base/logging.h"
 #include "webrtc/modules/include/module_common_types.h"
 #include "webrtc/modules/pacing/alr_detector.h"
 #include "webrtc/modules/pacing/bitrate_prober.h"
 #include "webrtc/modules/utility/include/process_thread.h"
 #include "webrtc/system_wrappers/include/clock.h"
 #include "webrtc/system_wrappers/include/field_trial.h"
@@ skipping 65 matching lines @@
 class PacketQueue {
  public:
   explicit PacketQueue(const Clock* clock)
       : bytes_(0),
         clock_(clock),
         queue_time_sum_(0),
         time_last_updated_(clock_->TimeInMilliseconds()) {}
   virtual ~PacketQueue() {}
 
   void Push(const Packet& packet) {
-    if (!AddToDupeSet(packet))
-      return;
-
     UpdateQueueTime(packet.enqueue_time_ms);
 
     // Store packet in list, use pointers in priority queue for cheaper moves.
     // Packets have a handle to its own iterator in the list, for easy removal
     // when popping from queue.
     packet_list_.push_front(packet);
     std::list<Packet>::iterator it = packet_list_.begin();
     it->this_it = it;          // Handle for direct removal from list.
     prio_queue_.push(&(*it));  // Pointer into list.
     bytes_ += packet.bytes;
   }
 
   const Packet& BeginPop() {
     const Packet& packet = *prio_queue_.top();
     prio_queue_.pop();
     return packet;
   }
 
   void CancelPop(const Packet& packet) { prio_queue_.push(&(*packet.this_it)); }
 
   void FinalizePop(const Packet& packet) {
-    RemoveFromDupeSet(packet);
     bytes_ -= packet.bytes;
     queue_time_sum_ -= (time_last_updated_ - packet.enqueue_time_ms);
     packet_list_.erase(packet.this_it);
     RTC_DCHECK_EQ(packet_list_.size(), prio_queue_.size());
     if (packet_list_.empty())
       RTC_DCHECK_EQ(0, queue_time_sum_);
   }
 
   bool Empty() const { return prio_queue_.empty(); }
 
@@ skipping 18 matching lines @@
     time_last_updated_ = timestamp_ms;
   }
 
   int64_t AverageQueueTimeMs() const {
     if (prio_queue_.empty())
       return 0;
     return queue_time_sum_ / packet_list_.size();
   }
 
  private:
-  // Try to add a packet to the set of ssrc/seqno identifiers currently in the
-  // queue. Return true if inserted, false if this is a duplicate.
-  bool AddToDupeSet(const Packet& packet) {
-    SsrcSeqNoMap::iterator it = dupe_map_.find(packet.ssrc);
-    if (it == dupe_map_.end()) {
-      // First for this ssrc, just insert.
-      dupe_map_[packet.ssrc].insert(packet.sequence_number);
-      return true;
-    }
-
-    // Insert returns a pair, where second is a bool set to true if new element.
-    return it->second.insert(packet.sequence_number).second;
-  }
-
-  void RemoveFromDupeSet(const Packet& packet) {
-    SsrcSeqNoMap::iterator it = dupe_map_.find(packet.ssrc);
-    RTC_DCHECK(it != dupe_map_.end());
-    it->second.erase(packet.sequence_number);
-    if (it->second.empty()) {
-      dupe_map_.erase(it);
-    }
-  }
-
-  // List of packets, in the order the were enqueued. Since dequeueing may
+  // List of packets, in the order they were enqueued. Since dequeueing may
   // occur out of order, use list instead of vector.
   std::list<Packet> packet_list_;
   // Priority queue of the packets, sorted according to Comparator.
   // Use pointers into list, to avoid moving whole struct within heap.
   std::priority_queue<Packet*, std::vector<Packet*>, Comparator> prio_queue_;
   // Total number of bytes in the queue.
   uint64_t bytes_;
-  // Map<ssrc, std::set<seq_no> >, for checking duplicates.
-  typedef std::map<uint32_t, std::set<uint16_t> > SsrcSeqNoMap;
-  SsrcSeqNoMap dupe_map_;
   const Clock* const clock_;
   int64_t queue_time_sum_;
   int64_t time_last_updated_;
 };
 
 class IntervalBudget {
  public:
   explicit IntervalBudget(int initial_target_rate_kbps)
       : target_rate_kbps_(initial_target_rate_kbps),
         bytes_remaining_(0) {}
@@ skipping 320 matching lines @@
 void PacedSender::UpdateBudgetWithElapsedTime(int64_t delta_time_ms) {
   media_budget_->IncreaseBudget(delta_time_ms);
   padding_budget_->IncreaseBudget(delta_time_ms);
 }
 
 void PacedSender::UpdateBudgetWithBytesSent(size_t bytes_sent) {
   media_budget_->UseBudget(bytes_sent);
   padding_budget_->UseBudget(bytes_sent);
 }
 }  // namespace webrtc