OLD | NEW |
1 // Copyright (c) 2012 The Chromium Authors. All rights reserved. | 1 // Copyright (c) 2012 The Chromium Authors. All rights reserved. |
2 // Use of this source code is governed by a BSD-style license that can be | 2 // Use of this source code is governed by a BSD-style license that can be |
3 // found in the LICENSE file. | 3 // found in the LICENSE file. |
4 | 4 |
5 #include "base/logging.h" | 5 #include "base/logging.h" |
6 #include "base/memory/scoped_ptr.h" | 6 #include "base/memory/scoped_ptr.h" |
7 #include "net/quic/congestion_control/quic_receipt_metrics_collector.h" | 7 #include "net/quic/congestion_control/quic_receipt_metrics_collector.h" |
8 #include "net/quic/congestion_control/quic_send_scheduler.h" | 8 #include "net/quic/congestion_control/quic_send_scheduler.h" |
9 #include "net/quic/test_tools/mock_clock.h" | 9 #include "net/quic/test_tools/mock_clock.h" |
10 #include "net/quic/quic_protocol.h" | 10 #include "net/quic/quic_protocol.h" |
(...skipping 28 matching lines...) Expand all Loading... |
39 EXPECT_EQ(QuicTime::Delta::Infinite(), | 39 EXPECT_EQ(QuicTime::Delta::Infinite(), |
40 sender_->TimeUntilSend(false)); | 40 sender_->TimeUntilSend(false)); |
41 clock_.AdvanceTime(QuicTime::Delta::FromMilliseconds(5)); | 41 clock_.AdvanceTime(QuicTime::Delta::FromMilliseconds(5)); |
42 EXPECT_EQ(QuicTime::Delta::Infinite(), | 42 EXPECT_EQ(QuicTime::Delta::Infinite(), |
43 sender_->TimeUntilSend(false)); | 43 sender_->TimeUntilSend(false)); |
44 } | 44 } |
45 | 45 |
46 TEST_F(QuicSendSchedulerTest, FixedRatePacing) { | 46 TEST_F(QuicSendSchedulerTest, FixedRatePacing) { |
47 SetUpCongestionType(kFixRate); | 47 SetUpCongestionType(kFixRate); |
48 QuicAckFrame ack; | 48 QuicAckFrame ack; |
49 ack.received_info.largest_received = 0; | 49 ack.received_info.largest_observed = 0; |
50 sender_->OnIncomingAckFrame(ack); | 50 sender_->OnIncomingAckFrame(ack); |
51 | 51 |
52 QuicCongestionFeedbackFrame feedback; | 52 QuicCongestionFeedbackFrame feedback; |
53 feedback.type = kFixRate; | 53 feedback.type = kFixRate; |
54 feedback.fix_rate.bitrate_in_bytes_per_second = 100000; | 54 feedback.fix_rate.bitrate_in_bytes_per_second = 100000; |
55 sender_->OnIncomingQuicCongestionFeedbackFrame(feedback); | 55 sender_->OnIncomingQuicCongestionFeedbackFrame(feedback); |
56 | 56 |
57 QuicTime acc_advance_time; | 57 QuicTime acc_advance_time; |
58 for (int i = 1; i <= 100; ++i) { | 58 for (int i = 1; i <= 100; ++i) { |
59 EXPECT_TRUE(sender_->TimeUntilSend(false).IsZero()); | 59 EXPECT_TRUE(sender_->TimeUntilSend(false).IsZero()); |
(...skipping 98 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
158 sender_->OnIncomingAckFrame(ack); | 158 sender_->OnIncomingAckFrame(ack); |
159 } | 159 } |
160 EXPECT_EQ(100000, sender_->BandwidthEstimate()); | 160 EXPECT_EQ(100000, sender_->BandwidthEstimate()); |
161 EXPECT_EQ(100000, sender_->PeakSustainedBandwidth()); | 161 EXPECT_EQ(100000, sender_->PeakSustainedBandwidth()); |
162 EXPECT_EQ(50000, sender_->SentBandwidth()); | 162 EXPECT_EQ(50000, sender_->SentBandwidth()); |
163 } | 163 } |
164 | 164 |
165 TEST_F(QuicSendSchedulerTest, Pacing) { | 165 TEST_F(QuicSendSchedulerTest, Pacing) { |
166 SetUpCongestionType(kFixRate); | 166 SetUpCongestionType(kFixRate); |
167 QuicAckFrame ack; | 167 QuicAckFrame ack; |
168 ack.received_info.largest_received = 0; | 168 ack.received_info.largest_observed = 0; |
169 sender_->OnIncomingAckFrame(ack); | 169 sender_->OnIncomingAckFrame(ack); |
170 | 170 |
171 QuicCongestionFeedbackFrame feedback; | 171 QuicCongestionFeedbackFrame feedback; |
172 feedback.type = kFixRate; | 172 feedback.type = kFixRate; |
173 // Test a high bitrate (8Mbit/s) to trigger pacing. | 173 // Test a high bitrate (8Mbit/s) to trigger pacing. |
174 feedback.fix_rate.bitrate_in_bytes_per_second = 1000000; | 174 feedback.fix_rate.bitrate_in_bytes_per_second = 1000000; |
175 sender_->OnIncomingQuicCongestionFeedbackFrame(feedback); | 175 sender_->OnIncomingQuicCongestionFeedbackFrame(feedback); |
176 | 176 |
177 QuicTime acc_advance_time; | 177 QuicTime acc_advance_time; |
178 for (int i = 1; i <= 100;) { | 178 for (int i = 1; i <= 100;) { |
179 EXPECT_TRUE(sender_->TimeUntilSend(false).IsZero()); | 179 EXPECT_TRUE(sender_->TimeUntilSend(false).IsZero()); |
180 EXPECT_EQ(kMaxPacketSize * 2, sender_->AvailableCongestionWindow()); | 180 EXPECT_EQ(kMaxPacketSize * 2, sender_->AvailableCongestionWindow()); |
181 sender_->SentPacket(i++, kMaxPacketSize, false); | 181 sender_->SentPacket(i++, kMaxPacketSize, false); |
182 EXPECT_TRUE(sender_->TimeUntilSend(false).IsZero()); | 182 EXPECT_TRUE(sender_->TimeUntilSend(false).IsZero()); |
183 sender_->SentPacket(i++, kMaxPacketSize, false); | 183 sender_->SentPacket(i++, kMaxPacketSize, false); |
184 QuicTime::Delta advance_time = sender_->TimeUntilSend(false); | 184 QuicTime::Delta advance_time = sender_->TimeUntilSend(false); |
185 clock_.AdvanceTime(advance_time); | 185 clock_.AdvanceTime(advance_time); |
186 acc_advance_time = acc_advance_time.Add(advance_time); | 186 acc_advance_time = acc_advance_time.Add(advance_time); |
187 // Ack the packets we sent. | 187 // Ack the packets we sent. |
188 ack.received_info.RecordReceived(i - 2); | 188 ack.received_info.RecordReceived(i - 2); |
189 sender_->OnIncomingAckFrame(ack); | 189 sender_->OnIncomingAckFrame(ack); |
190 ack.received_info.RecordReceived(i - 1); | 190 ack.received_info.RecordReceived(i - 1); |
191 sender_->OnIncomingAckFrame(ack); | 191 sender_->OnIncomingAckFrame(ack); |
192 } | 192 } |
193 EXPECT_EQ(QuicTime::FromMilliseconds(120), acc_advance_time); | 193 EXPECT_EQ(QuicTime::FromMilliseconds(120), acc_advance_time); |
194 } | 194 } |
195 | 195 |
196 } // namespace test | 196 } // namespace test |
197 } // namespace net | 197 } // namespace net |
OLD | NEW |