Add QUIC_VERSION_15 to add a revived_packets set to replace the

net/quic/quic_received_packet_manager_test.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 "net/quic/quic_received_packet_manager.h"
 
 #include <algorithm>
 #include <vector>
 
 #include "net/quic/test_tools/quic_received_packet_manager_peer.h"
@@ skipping 10 matching lines @@
 
 class QuicReceivedPacketManagerTest : public ::testing::Test {
  protected:
   QuicReceivedPacketManagerTest() : received_manager_(kTCP) { }
 
   void RecordPacketEntropyHash(QuicPacketSequenceNumber sequence_number,
                                QuicPacketEntropyHash entropy_hash) {
     QuicPacketHeader header;
     header.packet_sequence_number = sequence_number;
     header.entropy_hash = entropy_hash;
-    received_manager_.RecordPacketReceived(0u, header, QuicTime::Zero(), false);
+    received_manager_.RecordPacketReceived(0u, header, QuicTime::Zero());
   }
 
   QuicReceivedPacketManager received_manager_;
 };
 
 TEST_F(QuicReceivedPacketManagerTest, ReceivedPacketEntropyHash) {
   vector<pair<QuicPacketSequenceNumber, QuicPacketEntropyHash> > entropies;
   entropies.push_back(make_pair(1, 12));
   entropies.push_back(make_pair(7, 1));
   entropies.push_back(make_pair(2, 33));
@@ skipping 56 matching lines @@
   EXPECT_EQ(entropy_hash, received_manager_.EntropyHash(6));
 
   QuicReceivedPacketManagerPeer::RecalculateEntropyHash(
       &received_manager_, 1, 50);
   EXPECT_EQ(entropy_hash, received_manager_.EntropyHash(6));
 }
 
 TEST_F(QuicReceivedPacketManagerTest, DontWaitForPacketsBefore) {
   QuicPacketHeader header;
   header.packet_sequence_number = 2u;
-  received_manager_.RecordPacketReceived(0u, header, QuicTime::Zero(), false);
+  received_manager_.RecordPacketReceived(0u, header, QuicTime::Zero());
   header.packet_sequence_number = 7u;
-  received_manager_.RecordPacketReceived(0u, header, QuicTime::Zero(), false);
+  received_manager_.RecordPacketReceived(0u, header, QuicTime::Zero());
   EXPECT_TRUE(received_manager_.IsAwaitingPacket(3u));
   EXPECT_TRUE(received_manager_.IsAwaitingPacket(6u));
   EXPECT_TRUE(QuicReceivedPacketManagerPeer::DontWaitForPacketsBefore(
       &received_manager_, 4));
   EXPECT_FALSE(received_manager_.IsAwaitingPacket(3u));
   EXPECT_TRUE(received_manager_.IsAwaitingPacket(6u));
 }
 
 TEST_F(QuicReceivedPacketManagerTest, UpdateReceivedPacketInfo) {
   QuicPacketHeader header;
   header.packet_sequence_number = 2u;
   QuicTime two_ms = QuicTime::Zero().Add(QuicTime::Delta::FromMilliseconds(2));
-  received_manager_.RecordPacketReceived(0u, header, two_ms, false);
+  received_manager_.RecordPacketReceived(0u, header, two_ms);
 
   ReceivedPacketInfo info;
   received_manager_.UpdateReceivedPacketInfo(&info, QuicTime::Zero());
   // When UpdateReceivedPacketInfo with a time earlier than the time of the
   // largest observed packet, make sure that the delta is 0, not negative.
   EXPECT_EQ(QuicTime::Delta::Zero(), info.delta_time_largest_observed);
 
   QuicTime four_ms = QuicTime::Zero().Add(QuicTime::Delta::FromMilliseconds(4));
   received_manager_.UpdateReceivedPacketInfo(&info, four_ms);
   // When UpdateReceivedPacketInfo after not having received a new packet,
   // the delta should still be accurate.
   EXPECT_EQ(QuicTime::Delta::FromMilliseconds(2),
             info.delta_time_largest_observed);
 }
 
 }  // namespace
 }  // namespace test
 }  // namespace net