Change PacketKey to be unique for each frame packet by including

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/debug/dump_without_crashing.h"
 #include "base/message_loop/message_loop.h"
@@ skipping 13 matching lines @@
 // enqueued in the pacer.  This is used to detect bugs, reported as crash dumps.
 static const size_t kHugeQueueLengthSeconds = 10;
 static const size_t kRidiculousNumberOfPackets =
     kHugeQueueLengthSeconds * (kMaxBurstSize * 1000 / kPacingIntervalMs);
 
 }  // namespace
 
 DedupInfo::DedupInfo() : last_byte_acked_for_audio(0) {}
 
 // static
-PacketKey PacedPacketSender::MakePacketKey(const base::TimeTicks& ticks,
+PacketKey PacedPacketSender::MakePacketKey(PacketKey::PacketType packet_type,
+                                           uint32 frame_id,
                                            uint32 ssrc,
                                            uint16 packet_id) {
-  return std::make_pair(ticks, std::make_pair(ssrc, packet_id));
+  PacketKey key{packet_type, frame_id, ssrc, packet_id};
+  return key;
 }
 
 PacedSender::PacketSendRecord::PacketSendRecord()
     : last_byte_sent(0), last_byte_sent_for_audio(0) {}
 
 PacedSender::PacedSender(
     size_t target_burst_size,
     size_t max_burst_size,
     base::TickClock* clock,
     std::vector<PacketEvent>* recent_packet_events,
@@ skipping 70 matching lines @@
   PacketSendHistory::const_iterator it = send_history_.find(packet_key);
 
   // No history of previous transmission. It might be sent too long ago.
   if (it == send_history_.end())
     return true;
 
   // Suppose there is request to retransmit X and there is an audio
   // packet Y sent just before X. Reject retransmission of X if ACK for
   // Y has not been received.
   // Only do this for video packets.
-  if (packet_key.second.first == video_ssrc_) {
+  if (packet_key.ssrc == video_ssrc_) {
     if (dedup_info.last_byte_acked_for_audio &&
         it->second.last_byte_sent_for_audio &&
         dedup_info.last_byte_acked_for_audio <
         it->second.last_byte_sent_for_audio) {
       return false;
     }
   }
   // Retransmission interval has to be greater than |resend_interval|.
   if (now - it->second.time < dedup_info.resend_interval)
     return false;
@@ skipping 23 matching lines @@
     }
   }
   if (state_ == State_Unblocked) {
     SendStoredPackets();
   }
   return true;
 }
 
 bool PacedSender::SendRtcpPacket(uint32 ssrc, PacketRef packet) {
   if (state_ == State_TransportBlocked) {
-    priority_packet_list_[
-        PacedPacketSender::MakePacketKey(base::TimeTicks(), ssrc, 0)] =
-        make_pair(PacketType_RTCP, packet);
+    PacketKey key =
+        PacedPacketSender::MakePacketKey(PacketKey::RTCP, 0, ssrc, 0);
+    priority_packet_list_[key] = 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;
@@ skipping 12 matching lines @@
   PacketList::iterator i = list->begin();
   *packet_type = i->second.first;
   *packet_key = i->first;
   PacketRef ret = i->second.second;
   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();
+                   packet_key.ssrc) != priority_ssrcs_.end();
 }
 
 bool PacedSender::empty() const {
   return packet_list_.empty() && priority_packet_list_.empty();
 }
 
 size_t PacedSender::size() const {
   return packet_list_.size() + priority_packet_list_.size();
 }
 
@@ skipping 73 matching lines @@
         break;
     }
 
     const bool socket_blocked = !transport_->SendPacket(packet, cb);
 
     // Save the send record.
     send_record.last_byte_sent = transport_->GetBytesSent();
     send_record.last_byte_sent_for_audio = GetLastByteSentForSsrc(audio_ssrc_);
     send_history_[packet_key] = send_record;
     send_history_buffer_[packet_key] = send_record;
-    last_byte_sent_[packet_key.second.first] = send_record.last_byte_sent;
+    last_byte_sent_[packet_key.ssrc] = send_record.last_byte_sent;
 
     if (socket_blocked) {
       state_ = State_TransportBlocked;
       return;
     }
     current_burst_size_++;
   }
 
   // Keep ~0.5 seconds of data (1000 packets).
   if (send_history_buffer_.size() >=
@@ skipping 34 matching lines @@
   }
   success &= reader.Skip(2);
   success &= reader.ReadU16(&event.packet_id);
   success &= reader.ReadU16(&event.max_packet_id);
   event.size = packet.size();
   DCHECK(success);
 }
 
 }  // namespace cast
 }  // namespace media