Change PacketKey to be unique for each frame packet by including

media/cast/net/pacing/paced_sender_unittest.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 <stdint.h>
 
 #include "base/big_endian.h"
 #include "base/test/simple_test_tick_clock.h"
 #include "media/cast/net/pacing/paced_sender.h"
 #include "media/cast/test/fake_single_thread_task_runner.h"
@@ skipping 39 matching lines @@
 
  public:
   std::list<int> expected_packet_size_;
   int64 bytes_sent_;
 
   DISALLOW_COPY_AND_ASSIGN(TestPacketSender);
 };
 
 class PacedSenderTest : public ::testing::Test {
  protected:
-  PacedSenderTest() {
+  PacedSenderTest() : frame_id_(0) {
     testing_clock_.Advance(
         base::TimeDelta::FromMilliseconds(kStartMillisecond));
     task_runner_ = new test::FakeSingleThreadTaskRunner(&testing_clock_);
     paced_sender_.reset(new PacedSender(kTargetBurstSize, kMaxBurstSize,
                                         &testing_clock_, &packet_events_,
                                         &mock_transport_, task_runner_));
     paced_sender_->RegisterAudioSsrc(kAudioSsrc);
     paced_sender_->RegisterVideoSsrc(kVideoSsrc);
   }
 
   static void UpdateCastTransportStatus(CastTransportStatus status) {
     NOTREACHED();
   }
 
   SendPacketVector CreateSendPacketVector(size_t packet_size,
                                           int num_of_packets_in_frame,
                                           bool audio) {
     DCHECK_GE(packet_size, 12u);
     SendPacketVector packets;
-    base::TimeTicks frame_tick = testing_clock_.NowTicks();
-    // Advance the clock so that we don't get the same frame_tick
-    // next time this function is called.
-    testing_clock_.Advance(base::TimeDelta::FromMilliseconds(1));
     for (int i = 0; i < num_of_packets_in_frame; ++i) {
       PacketKey key = PacedPacketSender::MakePacketKey(
-          frame_tick,
-          audio ? kAudioSsrc : kVideoSsrc, // ssrc
+          PacketKey::RTP, frame_id_,
+          audio ? kAudioSsrc : kVideoSsrc,  // ssrc
           i);
 
       PacketRef packet(new base::RefCountedData<Packet>);
       packet->data.resize(packet_size, kValue);
       // Fill-in packet header fields to test the header parsing (for populating
       // the logging events).
       base::BigEndianWriter writer(reinterpret_cast<char*>(&packet->data[0]),
                                    packet_size);
       bool success = writer.Skip(4);
       success &= writer.WriteU32(kFrameRtpTimestamp);
       success &= writer.WriteU32(audio ? kAudioSsrc : kVideoSsrc);
       success &= writer.Skip(2);
       success &= writer.WriteU16(i);
       success &= writer.WriteU16(num_of_packets_in_frame - 1);
       CHECK(success);
       packets.push_back(std::make_pair(key, packet));
     }
+    // Increase |frame_id_| so that we don't get the same key next time this
+    // function is called.
+    ++frame_id_;
     return packets;
   }
 
   // Use this function to drain the packet list in PacedSender without having
   // to test the pacing implementation details.
   bool RunUntilEmpty(int max_tries) {
     for (int i = 0; i < max_tries; i++) {
       testing_clock_.Advance(base::TimeDelta::FromMilliseconds(10));
       task_runner_->RunTasks();
       if (mock_transport_.expected_packet_size_.empty())
         return true;
       i++;
     }
 
     return mock_transport_.expected_packet_size_.empty();
   }
 
   std::vector<PacketEvent> packet_events_;
   base::SimpleTestTickClock testing_clock_;
   TestPacketSender mock_transport_;
   scoped_refptr<test::FakeSingleThreadTaskRunner> task_runner_;
   scoped_ptr<PacedSender> paced_sender_;
+  uint32 frame_id_;
 
   DISALLOW_COPY_AND_ASSIGN(PacedSenderTest);
 };
 
 }  // namespace
 
 TEST_F(PacedSenderTest, PassThroughRtcp) {
   mock_transport_.AddExpectedSize(kSize1, 2);
   SendPacketVector packets = CreateSendPacketVector(kSize1, 1, true);
 
@@ skipping 315 matching lines @@
   EXPECT_TRUE(paced_sender_->ResendPackets(packets, dedup_info));
   EXPECT_EQ(static_cast<int64>(kSize1), mock_transport_.GetBytesSent());
 
   dedup_info.resend_interval = base::TimeDelta::FromMilliseconds(5);
   EXPECT_TRUE(paced_sender_->ResendPackets(packets, dedup_info));
   EXPECT_EQ(static_cast<int64>(2 * kSize1), mock_transport_.GetBytesSent());
 }
 
 }  // namespace cast
 }  // namespace media