Cast: Implement priority packets in PacedSender

media/cast/net/pacing/paced_sender.cc

 // Copyright 2014 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/net/pacing/paced_sender.h"
 
 #include "base/big_endian.h"
 #include "base/bind.h"
 #include "base/message_loop/message_loop.h"
 #include "media/cast/logging/logging_impl.h"
@@ skipping 42 matching lines @@
 PacedSender::~PacedSender() {}
 
 void PacedSender::RegisterAudioSsrc(uint32 audio_ssrc) {
   audio_ssrc_ = audio_ssrc;
 }
 
 void PacedSender::RegisterVideoSsrc(uint32 video_ssrc) {
   video_ssrc_ = video_ssrc;
 }
 
+void PacedSender::RegisterPrioritySsrc(uint32 ssrc) {
+  priority_ssrcs_.push_back(ssrc);
+}
+
 bool PacedSender::SendPackets(const SendPacketVector& packets) {
   if (packets.empty()) {
     return true;
   }
+  const bool high_priority = IsHighPriority(packets.begin()->first);
   for (size_t i = 0; i < packets.size(); i++) {
-    packet_list_[packets[i].first] =
-        make_pair(PacketType_Normal, packets[i].second);
+    DCHECK(IsHighPriority(packets[i].first) == high_priority);
+    if (high_priority) {
+      priority_packet_list_[packets[i].first] =
+          make_pair(PacketType_Normal, packets[i].second);
+    } else {
+      packet_list_[packets[i].first] =
+          make_pair(PacketType_Normal, packets[i].second);
+    }
   }
   if (state_ == State_Unblocked) {
     SendStoredPackets();
   }
   return true;
 }
 
 bool PacedSender::ResendPackets(const SendPacketVector& packets,
                                 base::TimeDelta dedupe_window) {
   if (packets.empty()) {
     return true;
   }
+  const bool high_priority = IsHighPriority(packets.begin()->first);
   base::TimeTicks now = clock_->NowTicks();
   for (size_t i = 0; i < packets.size(); i++) {
     std::map<PacketKey, base::TimeTicks>::const_iterator j =
         sent_time_.find(packets[i].first);
 
     if (j != sent_time_.end() && now - j->second < dedupe_window) {
       LogPacketEvent(packets[i].second->data, PACKET_RTX_REJECTED);
       continue;
     }
 
-    packet_list_[packets[i].first] =
-        make_pair(PacketType_Resend, packets[i].second);
+    DCHECK(IsHighPriority(packets[i].first) == high_priority);
+    if (high_priority) {
+      priority_packet_list_[packets[i].first] =
+          make_pair(PacketType_Resend, packets[i].second);
+    } else {
+      packet_list_[packets[i].first] =
+          make_pair(PacketType_Resend, packets[i].second);
+    }
   }
   if (state_ == State_Unblocked) {
     SendStoredPackets();
   }
   return true;
 }
 
 bool PacedSender::SendRtcpPacket(uint32 ssrc, PacketRef packet) {
   if (state_ == State_TransportBlocked) {
-    packet_list_[PacedPacketSender::MakePacketKey(base::TimeTicks(), ssrc, 0)] =
+    priority_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;
 }
 
 void PacedSender::CancelSendingPacket(const PacketKey& packet_key) {
   packet_list_.erase(packet_key);
+  priority_packet_list_.erase(packet_key);
 }
 
-PacketRef PacedSender::GetNextPacket(PacketType* packet_type,
+PacketRef PacedSender::PopNextPacket(PacketType* packet_type,
                                      PacketKey* packet_key) {
-  std::map<PacketKey, std::pair<PacketType, PacketRef> >::iterator i;
-  i = packet_list_.begin();
-  DCHECK(i != packet_list_.end());
+  PacketList* list = !priority_packet_list_.empty() ?
+      &priority_packet_list_ : &packet_list_;
+  DCHECK(!list->empty());
+  PacketList::iterator i = list->begin();
   *packet_type = i->second.first;
   *packet_key = i->first;
   PacketRef ret = i->second.second;
-  packet_list_.erase(i);
+  list->erase(i);
   return ret;
 }
 
+bool PacedSender::IsHighPriority(const PacketKey& packet_key) const {
+  return std::find(priority_ssrcs_.begin(), priority_ssrcs_.end(),
+                   packet_key.second.first) != priority_ssrcs_.end();
+}
+
 bool PacedSender::empty() const {
-  return packet_list_.empty();
+  return packet_list_.empty() && priority_packet_list_.empty();
 }
 
 size_t PacedSender::size() const {
-  return packet_list_.size();
+  return packet_list_.size() + priority_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 42 matching lines @@
   while (!empty()) {
     if (current_burst_size_ >= max_burst_size_) {
       transport_task_runner_->PostDelayedTask(FROM_HERE,
                                               cb,
                                               burst_end_ - now);
       state_ = State_BurstFull;
       return;
     }
     PacketType packet_type;
     PacketKey packet_key;
-    PacketRef packet = GetNextPacket(&packet_type, &packet_key);
+    PacketRef packet = PopNextPacket(&packet_type, &packet_key);
     sent_time_[packet_key] = now;
     sent_time_buffer_[packet_key] = now;
 
     switch (packet_type) {
       case PacketType_Resend:
         LogPacketEvent(packet->data, PACKET_RETRANSMITTED);
         break;
       case PacketType_Normal:
         LogPacketEvent(packet->data, PACKET_SENT_TO_NETWORK);
         break;
@@ skipping 37 matching lines @@
     return;
   }
 
   EventMediaType media_type = is_audio ? AUDIO_EVENT : VIDEO_EVENT;
   logging_->InsertSinglePacketEvent(clock_->NowTicks(), event, media_type,
       packet);
 }
 
 }  // namespace cast
 }  // namespace media