| Index: net/quic/quic_sent_packet_manager_test.cc
|
| diff --git a/net/quic/quic_sent_packet_manager_test.cc b/net/quic/quic_sent_packet_manager_test.cc
|
| index 517ea92af3c9b7a2a28c41354d22b348c8a9902a..7b87835099e35bf2178c27409814d1277a336242 100644
|
| --- a/net/quic/quic_sent_packet_manager_test.cc
|
| +++ b/net/quic/quic_sent_packet_manager_test.cc
|
| @@ -32,16 +32,15 @@ class QuicSentPacketManagerTest : public ::testing::TestWithParam<bool> {
|
| clock_.AdvanceTime(QuicTime::Delta::FromMilliseconds(1000));
|
| }
|
|
|
| - virtual ~QuicSentPacketManagerTest() {
|
| - STLDeleteElements(&packets_);
|
| - }
|
| + virtual ~QuicSentPacketManagerTest() { STLDeleteElements(&packets_); }
|
|
|
| void VerifyUnackedPackets(QuicPacketSequenceNumber* packets,
|
| size_t num_packets) {
|
| if (num_packets == 0) {
|
| EXPECT_FALSE(manager_.HasUnackedPackets());
|
| - EXPECT_EQ(0u, QuicSentPacketManagerPeer::GetNumRetransmittablePackets(
|
| - &manager_));
|
| + EXPECT_EQ(
|
| + 0u,
|
| + QuicSentPacketManagerPeer::GetNumRetransmittablePackets(&manager_));
|
| return;
|
| }
|
|
|
| @@ -61,14 +60,15 @@ class QuicSentPacketManagerTest : public ::testing::TestWithParam<bool> {
|
| }
|
| size_t num_retransmittable = 0;
|
| for (SequenceNumberSet::const_iterator it = unacked.begin();
|
| - it != unacked.end(); ++it) {
|
| + it != unacked.end();
|
| + ++it) {
|
| if (manager_.HasRetransmittableFrames(*it)) {
|
| ++num_retransmittable;
|
| }
|
| }
|
| - EXPECT_EQ(num_packets,
|
| - QuicSentPacketManagerPeer::GetNumRetransmittablePackets(
|
| - &manager_));
|
| + EXPECT_EQ(
|
| + num_packets,
|
| + QuicSentPacketManagerPeer::GetNumRetransmittablePackets(&manager_));
|
| EXPECT_EQ(num_packets, num_retransmittable);
|
| }
|
|
|
| @@ -80,8 +80,7 @@ class QuicSentPacketManagerTest : public ::testing::TestWithParam<bool> {
|
| QuicSentPacketManager::PendingRetransmission next_retransmission =
|
| manager_.NextPendingRetransmission();
|
| EXPECT_EQ(old_sequence_number, next_retransmission.sequence_number);
|
| - EXPECT_EQ(LOSS_RETRANSMISSION,
|
| - next_retransmission.transmission_type);
|
| + EXPECT_EQ(LOSS_RETRANSMISSION, next_retransmission.transmission_type);
|
| manager_.OnRetransmittedPacket(old_sequence_number, new_sequence_number);
|
| EXPECT_TRUE(QuicSentPacketManagerPeer::IsRetransmission(
|
| &manager_, new_sequence_number));
|
| @@ -105,62 +104,85 @@ class QuicSentPacketManagerTest : public ::testing::TestWithParam<bool> {
|
|
|
| SerializedPacket CreatePacket(QuicPacketSequenceNumber sequence_number,
|
| bool retransmittable) {
|
| - packets_.push_back(QuicPacket::NewDataPacket(
|
| - NULL, 1000, false, PACKET_8BYTE_CONNECTION_ID, false,
|
| - PACKET_6BYTE_SEQUENCE_NUMBER));
|
| + packets_.push_back(QuicPacket::NewDataPacket(NULL,
|
| + 1000,
|
| + false,
|
| + PACKET_8BYTE_CONNECTION_ID,
|
| + false,
|
| + PACKET_6BYTE_SEQUENCE_NUMBER));
|
| return SerializedPacket(
|
| - sequence_number, PACKET_6BYTE_SEQUENCE_NUMBER,
|
| - packets_.back(), 0u,
|
| + sequence_number,
|
| + PACKET_6BYTE_SEQUENCE_NUMBER,
|
| + packets_.back(),
|
| + 0u,
|
| retransmittable ? new RetransmittableFrames() : NULL);
|
| }
|
|
|
| SerializedPacket CreateFecPacket(QuicPacketSequenceNumber sequence_number) {
|
| - packets_.push_back(QuicPacket::NewFecPacket(
|
| - NULL, 1000, false, PACKET_8BYTE_CONNECTION_ID, false,
|
| - PACKET_6BYTE_SEQUENCE_NUMBER));
|
| - return SerializedPacket(sequence_number, PACKET_6BYTE_SEQUENCE_NUMBER,
|
| - packets_.back(), 0u, NULL);
|
| + packets_.push_back(QuicPacket::NewFecPacket(NULL,
|
| + 1000,
|
| + false,
|
| + PACKET_8BYTE_CONNECTION_ID,
|
| + false,
|
| + PACKET_6BYTE_SEQUENCE_NUMBER));
|
| + return SerializedPacket(sequence_number,
|
| + PACKET_6BYTE_SEQUENCE_NUMBER,
|
| + packets_.back(),
|
| + 0u,
|
| + NULL);
|
| }
|
|
|
| void SendDataPacket(QuicPacketSequenceNumber sequence_number) {
|
| EXPECT_CALL(*send_algorithm_, OnPacketSent(_, sequence_number, _, _))
|
| - .Times(1).WillOnce(Return(true));
|
| + .Times(1)
|
| + .WillOnce(Return(true));
|
| SerializedPacket packet(CreateDataPacket(sequence_number));
|
| manager_.OnSerializedPacket(packet);
|
| - manager_.OnPacketSent(sequence_number, clock_.Now(),
|
| - packet.packet->length(), NOT_RETRANSMISSION,
|
| + manager_.OnPacketSent(sequence_number,
|
| + clock_.Now(),
|
| + packet.packet->length(),
|
| + NOT_RETRANSMISSION,
|
| HAS_RETRANSMITTABLE_DATA);
|
| }
|
|
|
| void SendCryptoPacket(QuicPacketSequenceNumber sequence_number) {
|
| EXPECT_CALL(*send_algorithm_, OnPacketSent(_, sequence_number, _, _))
|
| - .Times(1).WillOnce(Return(true));
|
| + .Times(1)
|
| + .WillOnce(Return(true));
|
| SerializedPacket packet(CreateDataPacket(sequence_number));
|
| packet.retransmittable_frames->AddStreamFrame(
|
| new QuicStreamFrame(1, false, 0, IOVector()));
|
| manager_.OnSerializedPacket(packet);
|
| - manager_.OnPacketSent(sequence_number, clock_.ApproximateNow(),
|
| - packet.packet->length(), NOT_RETRANSMISSION,
|
| + manager_.OnPacketSent(sequence_number,
|
| + clock_.ApproximateNow(),
|
| + packet.packet->length(),
|
| + NOT_RETRANSMISSION,
|
| HAS_RETRANSMITTABLE_DATA);
|
| }
|
|
|
| void SendFecPacket(QuicPacketSequenceNumber sequence_number) {
|
| EXPECT_CALL(*send_algorithm_, OnPacketSent(_, sequence_number, _, _))
|
| - .Times(1).WillOnce(Return(true));
|
| + .Times(1)
|
| + .WillOnce(Return(true));
|
| SerializedPacket packet(CreateFecPacket(sequence_number));
|
| manager_.OnSerializedPacket(packet);
|
| - manager_.OnPacketSent(sequence_number, clock_.ApproximateNow(),
|
| - packet.packet->length(), NOT_RETRANSMISSION,
|
| + manager_.OnPacketSent(sequence_number,
|
| + clock_.ApproximateNow(),
|
| + packet.packet->length(),
|
| + NOT_RETRANSMISSION,
|
| NO_RETRANSMITTABLE_DATA);
|
| }
|
|
|
| void SendAckPacket(QuicPacketSequenceNumber sequence_number) {
|
| EXPECT_CALL(*send_algorithm_, OnPacketSent(_, sequence_number, _, _))
|
| - .Times(1).WillOnce(Return(false));
|
| + .Times(1)
|
| + .WillOnce(Return(false));
|
| SerializedPacket packet(CreatePacket(sequence_number, false));
|
| manager_.OnSerializedPacket(packet);
|
| - manager_.OnPacketSent(sequence_number, clock_.Now(),
|
| - packet.packet->length(), NOT_RETRANSMISSION,
|
| + manager_.OnPacketSent(sequence_number,
|
| + clock_.Now(),
|
| + packet.packet->length(),
|
| + NOT_RETRANSMISSION,
|
| NO_RETRANSMITTABLE_DATA);
|
| }
|
|
|
| @@ -170,14 +192,17 @@ class QuicSentPacketManagerTest : public ::testing::TestWithParam<bool> {
|
| EXPECT_TRUE(manager_.HasPendingRetransmissions());
|
| EXPECT_CALL(*send_algorithm_,
|
| OnPacketSent(_, retransmission_sequence_number, _, _))
|
| - .Times(1).WillOnce(Return(true));
|
| + .Times(1)
|
| + .WillOnce(Return(true));
|
| const QuicSentPacketManager::PendingRetransmission pending =
|
| manager_.NextPendingRetransmission();
|
| - manager_.OnRetransmittedPacket(
|
| - pending.sequence_number, retransmission_sequence_number);
|
| + manager_.OnRetransmittedPacket(pending.sequence_number,
|
| + retransmission_sequence_number);
|
| manager_.OnPacketSent(retransmission_sequence_number,
|
| - clock_.ApproximateNow(), 1000,
|
| - pending.transmission_type, HAS_RETRANSMITTABLE_DATA);
|
| + clock_.ApproximateNow(),
|
| + 1000,
|
| + pending.transmission_type,
|
| + HAS_RETRANSMITTABLE_DATA);
|
| }
|
|
|
| QuicSentPacketManager manager_;
|
| @@ -194,9 +219,9 @@ TEST_F(QuicSentPacketManagerTest, IsUnacked) {
|
|
|
| manager_.OnSerializedPacket(serialized_packet);
|
|
|
| - QuicPacketSequenceNumber unacked[] = { 1 };
|
| + QuicPacketSequenceNumber unacked[] = {1};
|
| VerifyUnackedPackets(unacked, arraysize(unacked));
|
| - QuicPacketSequenceNumber retransmittable[] = { 1 };
|
| + QuicPacketSequenceNumber retransmittable[] = {1};
|
| VerifyRetransmittablePackets(retransmittable, arraysize(retransmittable));
|
| }
|
|
|
| @@ -205,9 +230,9 @@ TEST_F(QuicSentPacketManagerTest, IsUnAckedRetransmit) {
|
| RetransmitPacket(1, 2);
|
|
|
| EXPECT_TRUE(QuicSentPacketManagerPeer::IsRetransmission(&manager_, 2));
|
| - QuicPacketSequenceNumber unacked[] = { 1, 2 };
|
| + QuicPacketSequenceNumber unacked[] = {1, 2};
|
| VerifyUnackedPackets(unacked, arraysize(unacked));
|
| - QuicPacketSequenceNumber retransmittable[] = { 2 };
|
| + QuicPacketSequenceNumber retransmittable[] = {2};
|
| VerifyRetransmittablePackets(retransmittable, arraysize(retransmittable));
|
| }
|
|
|
| @@ -224,7 +249,7 @@ TEST_F(QuicSentPacketManagerTest, RetransmitThenAck) {
|
| manager_.OnIncomingAck(received_info, clock_.Now());
|
|
|
| // Packet 1 is unacked, pending, but not retransmittable.
|
| - QuicPacketSequenceNumber unacked[] = { 1 };
|
| + QuicPacketSequenceNumber unacked[] = {1};
|
| VerifyUnackedPackets(unacked, arraysize(unacked));
|
| EXPECT_TRUE(QuicSentPacketManagerPeer::HasPendingPackets(&manager_));
|
| VerifyRetransmittablePackets(NULL, 0);
|
| @@ -290,7 +315,7 @@ TEST_F(QuicSentPacketManagerTest, RetransmitAndSendThenAckPrevious) {
|
| manager_.OnIncomingAck(received_info, clock_.ApproximateNow());
|
|
|
| // 2 remains unacked, but no packets have retransmittable data.
|
| - QuicPacketSequenceNumber unacked[] = { 2 };
|
| + QuicPacketSequenceNumber unacked[] = {2};
|
| VerifyUnackedPackets(unacked, arraysize(unacked));
|
| EXPECT_TRUE(QuicSentPacketManagerPeer::HasPendingPackets(&manager_));
|
| VerifyRetransmittablePackets(NULL, 0);
|
| @@ -303,8 +328,11 @@ TEST_F(QuicSentPacketManagerTest, RetransmitThenAckPreviousThenNackRetransmit) {
|
| RetransmitPacket(1, 2);
|
| EXPECT_CALL(*send_algorithm_, OnPacketSent(_, 2, _, _))
|
| .WillOnce(Return(true));
|
| - manager_.OnPacketSent(2, clock_.ApproximateNow(), 1000,
|
| - LOSS_RETRANSMISSION, HAS_RETRANSMITTABLE_DATA);
|
| + manager_.OnPacketSent(2,
|
| + clock_.ApproximateNow(),
|
| + 1000,
|
| + LOSS_RETRANSMISSION,
|
| + HAS_RETRANSMITTABLE_DATA);
|
| QuicTime::Delta rtt = QuicTime::Delta::FromMilliseconds(15);
|
| clock_.AdvanceTime(rtt);
|
|
|
| @@ -391,7 +419,7 @@ TEST_F(QuicSentPacketManagerTest, RetransmitTwiceThenAckFirst) {
|
| manager_.OnIncomingAck(received_info, clock_.ApproximateNow());
|
|
|
| // 2 and 3 remain unacked, but no packets have retransmittable data.
|
| - QuicPacketSequenceNumber unacked[] = { 2, 3 };
|
| + QuicPacketSequenceNumber unacked[] = {2, 3};
|
| VerifyUnackedPackets(unacked, arraysize(unacked));
|
| EXPECT_TRUE(QuicSentPacketManagerPeer::HasPendingPackets(&manager_));
|
| VerifyRetransmittablePackets(NULL, 0);
|
| @@ -405,7 +433,7 @@ TEST_F(QuicSentPacketManagerTest, RetransmitTwiceThenAckFirst) {
|
| EXPECT_CALL(*send_algorithm_, OnPacketAcked(4, _));
|
| manager_.OnIncomingAck(received_info, clock_.ApproximateNow());
|
|
|
| - QuicPacketSequenceNumber unacked2[] = { 2 };
|
| + QuicPacketSequenceNumber unacked2[] = {2};
|
| VerifyUnackedPackets(unacked2, arraysize(unacked2));
|
| EXPECT_TRUE(QuicSentPacketManagerPeer::HasPendingPackets(&manager_));
|
|
|
| @@ -438,10 +466,10 @@ TEST_F(QuicSentPacketManagerTest, LoseButDontRetransmitRevivedPacket) {
|
| manager_.OnIncomingAck(received_info, clock_.ApproximateNow());
|
|
|
| EXPECT_FALSE(manager_.HasPendingRetransmissions());
|
| - QuicPacketSequenceNumber unacked[] = { 1, 4 };
|
| + QuicPacketSequenceNumber unacked[] = {1, 4};
|
| VerifyUnackedPackets(unacked, arraysize(unacked));
|
| EXPECT_TRUE(QuicSentPacketManagerPeer::HasPendingPackets(&manager_));
|
| - QuicPacketSequenceNumber retransmittable[] = { 4 };
|
| + QuicPacketSequenceNumber retransmittable[] = {4};
|
| VerifyRetransmittablePackets(retransmittable, arraysize(retransmittable));
|
|
|
| // Ack the 4th packet and expect the 1st to be considered lost.
|
| @@ -474,9 +502,9 @@ TEST_F(QuicSentPacketManagerTest, MarkLostThenReviveAndDontRetransmitPacket) {
|
| manager_.OnIncomingAck(received_info, clock_.ApproximateNow());
|
|
|
| EXPECT_TRUE(manager_.HasPendingRetransmissions());
|
| - QuicPacketSequenceNumber unacked[] = { 1, 5 };
|
| + QuicPacketSequenceNumber unacked[] = {1, 5};
|
| VerifyUnackedPackets(unacked, arraysize(unacked));
|
| - QuicPacketSequenceNumber retransmittable[] = { 1 };
|
| + QuicPacketSequenceNumber retransmittable[] = {1};
|
| VerifyRetransmittablePackets(retransmittable, arraysize(retransmittable));
|
|
|
| // Ack 5th packet (FEC) and revive 1st packet. 1st packet should now be
|
| @@ -512,9 +540,9 @@ TEST_F(QuicSentPacketManagerTest, TruncatedAck) {
|
| manager_.OnIncomingAck(received_info, clock_.Now());
|
|
|
| // High water mark will be raised.
|
| - QuicPacketSequenceNumber unacked[] = { 2, 3, 4 };
|
| + QuicPacketSequenceNumber unacked[] = {2, 3, 4};
|
| VerifyUnackedPackets(unacked, arraysize(unacked));
|
| - QuicPacketSequenceNumber retransmittable[] = { 4 };
|
| + QuicPacketSequenceNumber retransmittable[] = {4};
|
| VerifyRetransmittablePackets(retransmittable, arraysize(retransmittable));
|
| }
|
|
|
| @@ -556,9 +584,9 @@ TEST_F(QuicSentPacketManagerTest, AckPreviousTransmissionThenTruncatedAck) {
|
| }
|
|
|
| // High water mark will be raised.
|
| - QuicPacketSequenceNumber unacked[] = { 4, 5, 6, 7, 8, 9 };
|
| + QuicPacketSequenceNumber unacked[] = {4, 5, 6, 7, 8, 9};
|
| VerifyUnackedPackets(unacked, arraysize(unacked));
|
| - QuicPacketSequenceNumber retransmittable[] = { 5, 6, 7, 8, 9 };
|
| + QuicPacketSequenceNumber retransmittable[] = {5, 6, 7, 8, 9};
|
| VerifyRetransmittablePackets(retransmittable, arraysize(retransmittable));
|
| }
|
|
|
| @@ -603,7 +631,7 @@ TEST_F(QuicSentPacketManagerTest, GetLeastUnackedPacketAndDiscard) {
|
| manager_.OnSerializedPacket(serialized_packet3);
|
| EXPECT_EQ(1u, manager_.GetLeastUnackedSentPacket());
|
|
|
| - QuicPacketSequenceNumber unacked[] = { 1, 2, 3 };
|
| + QuicPacketSequenceNumber unacked[] = {1, 2, 3};
|
| VerifyUnackedPackets(unacked, arraysize(unacked));
|
| VerifyRetransmittablePackets(NULL, 0);
|
|
|
| @@ -627,20 +655,20 @@ TEST_F(QuicSentPacketManagerTest, GetSentTime) {
|
|
|
| SerializedPacket serialized_packet(CreateFecPacket(1));
|
| manager_.OnSerializedPacket(serialized_packet);
|
| - EXPECT_CALL(*send_algorithm_, OnPacketSent(_, 1, _, _))
|
| - .Times(1).WillOnce(Return(true));
|
| + EXPECT_CALL(*send_algorithm_, OnPacketSent(_, 1, _, _)).Times(1).WillOnce(
|
| + Return(true));
|
| manager_.OnPacketSent(
|
| 1, QuicTime::Zero(), 1000, NOT_RETRANSMISSION, NO_RETRANSMITTABLE_DATA);
|
|
|
| SerializedPacket serialized_packet2(CreateFecPacket(2));
|
| QuicTime sent_time = QuicTime::Zero().Add(QuicTime::Delta::FromSeconds(1));
|
| manager_.OnSerializedPacket(serialized_packet2);
|
| - EXPECT_CALL(*send_algorithm_, OnPacketSent(_, 2, _, _))
|
| - .Times(1).WillOnce(Return(true));
|
| + EXPECT_CALL(*send_algorithm_, OnPacketSent(_, 2, _, _)).Times(1).WillOnce(
|
| + Return(true));
|
| manager_.OnPacketSent(
|
| 2, sent_time, 1000, NOT_RETRANSMISSION, NO_RETRANSMITTABLE_DATA);
|
|
|
| - QuicPacketSequenceNumber unacked[] = { 1, 2 };
|
| + QuicPacketSequenceNumber unacked[] = {1, 2};
|
| VerifyUnackedPackets(unacked, arraysize(unacked));
|
| VerifyRetransmittablePackets(NULL, 0);
|
|
|
| @@ -667,8 +695,7 @@ TEST_F(QuicSentPacketManagerTest, FackRetransmit17Packets) {
|
| received_info.missing_packets.insert(i);
|
| }
|
| EXPECT_CALL(*send_algorithm_, OnRttUpdated(_));
|
| - EXPECT_CALL(*send_algorithm_,
|
| - OnPacketAcked(kLargestObserved, _)).Times(1);
|
| + EXPECT_CALL(*send_algorithm_, OnPacketAcked(kLargestObserved, _)).Times(1);
|
| EXPECT_CALL(*send_algorithm_, OnPacketLost(_, _)).Times(17);
|
| EXPECT_CALL(*send_algorithm_, OnPacketAbandoned(_, _)).Times(17);
|
| manager_.OnIncomingAck(received_info, clock_.Now());
|
| @@ -756,8 +783,7 @@ TEST_F(QuicSentPacketManagerTest, Rtt) {
|
| clock_.AdvanceTime(QuicTime::Delta::FromMilliseconds(20));
|
|
|
| EXPECT_CALL(*send_algorithm_, OnRttUpdated(sequence_number));
|
| - EXPECT_CALL(*send_algorithm_,
|
| - OnPacketAcked(sequence_number, _)).Times(1);
|
| + EXPECT_CALL(*send_algorithm_, OnPacketAcked(sequence_number, _)).Times(1);
|
| ReceivedPacketInfo received_info;
|
| received_info.largest_observed = sequence_number;
|
| received_info.delta_time_largest_observed =
|
| @@ -777,8 +803,7 @@ TEST_F(QuicSentPacketManagerTest, RttWithInvalidDelta) {
|
| clock_.AdvanceTime(expected_rtt);
|
|
|
| EXPECT_CALL(*send_algorithm_, OnRttUpdated(sequence_number));
|
| - EXPECT_CALL(*send_algorithm_,
|
| - OnPacketAcked(sequence_number, _)).Times(1);
|
| + EXPECT_CALL(*send_algorithm_, OnPacketAcked(sequence_number, _)).Times(1);
|
| ReceivedPacketInfo received_info;
|
| received_info.largest_observed = sequence_number;
|
| received_info.delta_time_largest_observed =
|
| @@ -797,8 +822,7 @@ TEST_F(QuicSentPacketManagerTest, RttWithInfiniteDelta) {
|
| clock_.AdvanceTime(expected_rtt);
|
|
|
| EXPECT_CALL(*send_algorithm_, OnRttUpdated(sequence_number));
|
| - EXPECT_CALL(*send_algorithm_,
|
| - OnPacketAcked(sequence_number, _)).Times(1);
|
| + EXPECT_CALL(*send_algorithm_, OnPacketAcked(sequence_number, _)).Times(1);
|
| ReceivedPacketInfo received_info;
|
| received_info.largest_observed = sequence_number;
|
| received_info.delta_time_largest_observed = QuicTime::Delta::Infinite();
|
| @@ -816,8 +840,7 @@ TEST_F(QuicSentPacketManagerTest, RttZeroDelta) {
|
| clock_.AdvanceTime(expected_rtt);
|
|
|
| EXPECT_CALL(*send_algorithm_, OnRttUpdated(sequence_number));
|
| - EXPECT_CALL(*send_algorithm_, OnPacketAcked(sequence_number, _))
|
| - .Times(1);
|
| + EXPECT_CALL(*send_algorithm_, OnPacketAcked(sequence_number, _)).Times(1);
|
| ReceivedPacketInfo received_info;
|
| received_info.largest_observed = sequence_number;
|
| received_info.delta_time_largest_observed = QuicTime::Delta::Zero();
|
| @@ -1036,7 +1059,7 @@ TEST_F(QuicSentPacketManagerTest,
|
| // version negotiation.
|
| EXPECT_CALL(*send_algorithm_, OnPacketAbandoned(_, _)).Times(1);
|
| manager_.RetransmitUnackedPackets(ALL_PACKETS);
|
| - QuicPacketSequenceNumber unacked[] = { 1, 2 };
|
| + QuicPacketSequenceNumber unacked[] = {1, 2};
|
| VerifyUnackedPackets(unacked, arraysize(unacked));
|
| EXPECT_TRUE(manager_.HasPendingRetransmissions());
|
| EXPECT_TRUE(QuicSentPacketManagerPeer::HasUnackedCryptoPackets(&manager_));
|
| @@ -1079,14 +1102,14 @@ TEST_F(QuicSentPacketManagerTest, GetTransmissionTimeCryptoHandshake) {
|
| SendCryptoPacket(1);
|
|
|
| // Check the min.
|
| - QuicSentPacketManagerPeer::GetRttStats(&manager_)->set_initial_rtt_us(
|
| - 1 * base::Time::kMicrosecondsPerMillisecond);
|
| + QuicSentPacketManagerPeer::GetRttStats(&manager_)
|
| + ->set_initial_rtt_us(1 * base::Time::kMicrosecondsPerMillisecond);
|
| EXPECT_EQ(clock_.Now().Add(QuicTime::Delta::FromMilliseconds(10)),
|
| manager_.GetRetransmissionTime());
|
|
|
| // Test with a standard smoothed RTT.
|
| - QuicSentPacketManagerPeer::GetRttStats(&manager_)->set_initial_rtt_us(
|
| - 100 * base::Time::kMicrosecondsPerMillisecond);
|
| + QuicSentPacketManagerPeer::GetRttStats(&manager_)
|
| + ->set_initial_rtt_us(100 * base::Time::kMicrosecondsPerMillisecond);
|
|
|
| QuicTime::Delta srtt = manager_.GetRttStats()->SmoothedRtt();
|
| QuicTime expected_time = clock_.Now().Add(srtt.Multiply(1.5));
|
| @@ -1109,14 +1132,14 @@ TEST_F(QuicSentPacketManagerTest, GetTransmissionTimeTailLossProbe) {
|
| SendDataPacket(2);
|
|
|
| // Check the min.
|
| - QuicSentPacketManagerPeer::GetRttStats(&manager_)->set_initial_rtt_us(
|
| - 1 * base::Time::kMicrosecondsPerMillisecond);
|
| + QuicSentPacketManagerPeer::GetRttStats(&manager_)
|
| + ->set_initial_rtt_us(1 * base::Time::kMicrosecondsPerMillisecond);
|
| EXPECT_EQ(clock_.Now().Add(QuicTime::Delta::FromMilliseconds(10)),
|
| manager_.GetRetransmissionTime());
|
|
|
| // Test with a standard smoothed RTT.
|
| - QuicSentPacketManagerPeer::GetRttStats(&manager_)->set_initial_rtt_us(
|
| - 100 * base::Time::kMicrosecondsPerMillisecond);
|
| + QuicSentPacketManagerPeer::GetRttStats(&manager_)
|
| + ->set_initial_rtt_us(100 * base::Time::kMicrosecondsPerMillisecond);
|
| QuicTime::Delta srtt = manager_.GetRttStats()->SmoothedRtt();
|
| QuicTime::Delta expected_tlp_delay = srtt.Multiply(2);
|
| QuicTime expected_time = clock_.Now().Add(expected_tlp_delay);
|
| @@ -1133,10 +1156,10 @@ TEST_F(QuicSentPacketManagerTest, GetTransmissionTimeTailLossProbe) {
|
| }
|
|
|
| TEST_F(QuicSentPacketManagerTest, GetTransmissionTimeRTO) {
|
| - QuicSentPacketManagerPeer::GetRttStats(&manager_)->UpdateRtt(
|
| - QuicTime::Delta::FromMilliseconds(100),
|
| - QuicTime::Delta::Zero(),
|
| - QuicTime::Zero());
|
| + QuicSentPacketManagerPeer::GetRttStats(&manager_)
|
| + ->UpdateRtt(QuicTime::Delta::FromMilliseconds(100),
|
| + QuicTime::Delta::Zero(),
|
| + QuicTime::Zero());
|
|
|
| SendDataPacket(1);
|
| SendDataPacket(2);
|
| @@ -1247,8 +1270,8 @@ TEST_F(QuicSentPacketManagerTest, GetLossDelay) {
|
|
|
| TEST_F(QuicSentPacketManagerTest, NegotiateTimeLossDetection) {
|
| EXPECT_EQ(kNack,
|
| - QuicSentPacketManagerPeer::GetLossAlgorithm(
|
| - &manager_)->GetLossDetectionType());
|
| + QuicSentPacketManagerPeer::GetLossAlgorithm(&manager_)
|
| + ->GetLossDetectionType());
|
|
|
| QuicConfig config;
|
| QuicConfigPeer::SetReceivedLossDetection(&config, kTIME);
|
| @@ -1256,11 +1279,10 @@ TEST_F(QuicSentPacketManagerTest, NegotiateTimeLossDetection) {
|
| manager_.SetFromConfig(config);
|
|
|
| EXPECT_EQ(kTime,
|
| - QuicSentPacketManagerPeer::GetLossAlgorithm(
|
| - &manager_)->GetLossDetectionType());
|
| + QuicSentPacketManagerPeer::GetLossAlgorithm(&manager_)
|
| + ->GetLossDetectionType());
|
| }
|
|
|
| -
|
| } // namespace
|
| } // namespace test
|
| } // namespace net
|
|
|
Chromium Code Reviews
