Cast: Deduplicate packets in paced sender and always send older packets first

media/cast/transport/pacing/paced_sender.cc

 // Copyright 2013 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "media/cast/transport/pacing/paced_sender.h"
 
 #include "base/big_endian.h"
 #include "base/bind.h"
 #include "base/message_loop/message_loop.h"
 
@@ skipping 17 matching lines @@
     return is_audio ? media::cast::kAudioPacketRetransmitted
                     : media::cast::kVideoPacketRetransmitted;
   } else {
     return is_audio ? media::cast::kAudioPacketSentToNetwork
                     : media::cast::kVideoPacketSentToNetwork;
   }
 }
 
 }  // namespace
 
+
+PacketKey PacedPacketSender::MakePacketKey(const base::TimeTicks& ticks,
+                                           unsigned int ssrc,
+                                           uint16 packet_id) {
+  return std::make_pair(ticks, std::make_pair(ssrc, packet_id));
+}
+
 PacedSender::PacedSender(
     base::TickClock* clock,
     LoggingImpl* logging,
     PacketSender* transport,
     const scoped_refptr<base::SingleThreadTaskRunner>& transport_task_runner)
     : clock_(clock),
       logging_(logging),
       transport_(transport),
       transport_task_runner_(transport_task_runner),
       audio_ssrc_(0),
       video_ssrc_(0),
       max_burst_size_(kTargetBurstSize),
       next_max_burst_size_(kTargetBurstSize),
       next_next_max_burst_size_(kTargetBurstSize),
       current_burst_size_(0),
       state_(State_Unblocked),
       weak_factory_(this) {
 }
 
 PacedSender::~PacedSender() {}
 
 void PacedSender::RegisterAudioSsrc(uint32 audio_ssrc) {
   audio_ssrc_ = audio_ssrc;
 }
 
 void PacedSender::RegisterVideoSsrc(uint32 video_ssrc) {
   video_ssrc_ = video_ssrc;
 }
 
-bool PacedSender::SendPackets(const PacketList& packets) {
+bool PacedSender::SendPackets(const SendPacketVector& packets) {
   if (packets.empty()) {
     return true;
   }
-  packet_list_.insert(packet_list_.end(), packets.begin(), packets.end());
+  for (size_t i = 0; i < packets.size(); i++) {
+    packet_list_[packets[i].first] =
+        make_pair(PacketType_Normal, packets[i].second);
+  }
   if (state_ == State_Unblocked) {
     SendStoredPackets();
   }
   return true;
 }
 
-bool PacedSender::ResendPackets(const PacketList& packets) {
+bool PacedSender::ResendPackets(const SendPacketVector& packets) {
   if (packets.empty()) {
     return true;
   }
-  resend_packet_list_.insert(resend_packet_list_.end(),
-                             packets.begin(),
-                             packets.end());
+  for (size_t i = 0; i < packets.size(); i++) {
+    packet_list_[packets[i].first] =
+        make_pair(PacketType_Resend, packets[i].second);
+  }
   if (state_ == State_Unblocked) {
     SendStoredPackets();
   }
   return true;
 }
 
-bool PacedSender::SendRtcpPacket(PacketRef packet) {
+bool PacedSender::SendRtcpPacket(unsigned int ssrc, PacketRef packet) {
   if (state_ == State_TransportBlocked) {
-
-    rtcp_packet_list_.push_back(packet);
+    packet_list_[PacedPacketSender::MakePacketKey(base::TimeTicks(), ssrc, 0)] =
+        make_pair(PacketType_RTCP, packet);
   } else {
     // We pass the RTCP packets straight through.
     if (!transport_->SendPacket(
             packet,
             base::Bind(&PacedSender::SendStoredPackets,
                        weak_factory_.GetWeakPtr()))) {
       state_ = State_TransportBlocked;
     }
 
   }
   return true;
 }
 
 PacketRef PacedSender::GetNextPacket(PacketType* packet_type) {
-  PacketRef ret;
-  if (!rtcp_packet_list_.empty()) {
-    ret = rtcp_packet_list_.front();
-    rtcp_packet_list_.pop_front();
-    *packet_type = PacketType_RTCP;
-  } else if (!resend_packet_list_.empty()) {
-    ret = resend_packet_list_.front();
-    resend_packet_list_.pop_front();
-    *packet_type = PacketType_Resend;
-  } else if (!packet_list_.empty()) {
-    ret = packet_list_.front();
-    packet_list_.pop_front();
-    *packet_type = PacketType_Normal;
-  } else {
-    NOTREACHED();
-  }
+  std::map<PacketKey, std::pair<PacketType, PacketRef> >::iterator i;
+  i = packet_list_.begin();
+  *packet_type = i->second.first;

[miu, 2014/04/24 00:09:06]

nit: Suggest DCHECK(i != packet_list_.end());

[hubbe, 2014/04/24 18:36:42]

Done.

+  PacketRef ret = i->second.second;
+  packet_list_.erase(i);
   return ret;
 }
 
 bool PacedSender::empty() const {
-  return rtcp_packet_list_.empty() &&
-      resend_packet_list_.empty() &&
-      packet_list_.empty();
+  return packet_list_.empty();
 }
 
 size_t PacedSender::size() const {
-  return rtcp_packet_list_.size() +
-      resend_packet_list_.size() +
-      packet_list_.size();
+  return packet_list_.size();
 }
 
 // This function can be called from three places:
 // 1. User called one of the Send* functions and we were in an unblocked state.
 // 2. state_ == State_TransportBlocked and the transport is calling us to
 //    let us know that it's ok to send again.
 // 3. state_ == State_BurstFull and there are still packets to send. In this
 //    case we called PostDelayedTask on this function to start a new burst.
 void PacedSender::SendStoredPackets() {
   State previous_state = state_;
@@ skipping 88 matching lines @@
   }
 
   CastLoggingEvent event = GetLoggingEvent(is_audio, retransmit);
 
   logging_->InsertSinglePacketEvent(clock_->NowTicks(), event, packet);
 }
 
 }  // namespace transport
 }  // namespace cast
 }  // namespace media