Land recent QUIC changes.

Count the number of retransmissions for a packet due to RTO and explicit nacks and implement exponential backoff based on number of retransmissions.

Merge internal change: 41823946

QuicConnection now packetizes acks and congestion control frames even more lazily and packs control frames with up to 1 stream frame.

Merge internal change: 41805161

Remove nitty-gritties of QuicFramer from QuicTimeWaitListManager and remove some static methods from QuicFramer.

Merge internal change: 41795314

Store socket addresses in QuicConnection.h instead of pushing it down to QuicFramer.h and getting it back from there.

Merge internal change: 41768211

Retransmit largest_observed_ packet if its missing.

Merge internal change: 41743584

Split framer packet creation into size determination and packet creation methods in order to ensure the maximum number of frames are fit into a single packet.

Merge internal change: 41702016

Handle packet reordering for queued packets.

Merge internal change: 41701179

Bug fix for retransmission order.

Merge internal change: 41638847

Adding basic dispatcher stats for QUIC

Merge internal change: 41630921

Minor fixes in quic_connection.cc

Merge internal change: 41610652

Use priority queue to maintain the list of sequence numbers to be retransmitted. This will enable us to do an exponential backoff for lost packets.

Merge internal change: 41582526

Adding DISALLOW_COPY_AND_ASSIGN to all congestion control classes that were missing it. And a few nits.

Merge internal change: 41580553

Break circular dependency between quic_protocol.h and quic_bandwidth.h

Merge internal change: 41578776

Fix uninitialized memory access in quic_framer_test.

Merge internal change: 41558816

Cleanup, consolidated quic_send_scheduler with quic_congestion_manager

Merge internal change: 41549823

Set the retransmit alarm only when we successfully write the packet to the socket instead of setting it when we attempt to write.

Merge internal change: 41547192

Introduced QuicByteCount and moved TCP receive_bytes packing to QuicFramer where it belongs.

Merge internal change: 41546840

Fix a bug with how FEC groups were being created in QUIC.  Now opening multiple and always closing the group.

Merge internal change: 41538221

Removing QUIC logspam

Merge internal change: 41537896

Exposing ReadPublicHeader and ReadPublicResetPacket static methods which don't take a dependency on reader_(unlike Process..() methods).

Merge internal change: 41535886

Use "test" not "testing" for test namespaces to be consistent with other QUIC code.

Merge internal change: 41534488

Fix a number of minor issues that came up in landing recent chrome changes.

Merge internal change: 41531793

Removed the QuicReceiptMetricsCollector and started using the ReceiveAlgorithmInterface directly in the CongestionManager. The QuicReceiptMetricsCollector did not provide any functionality.

Merge internal change: 41486246

Integrating new quic bandwidth class

Merge internal change: 41473682

R=jar@chromium.org
BUG=


Review URL: https://chromiumcodereview.appspot.com/12145002

git-svn-id: svn://svn.chromium.org/chrome/trunk/src@180299 0039d316-1c4b-4281-b951-d872f2087c98

1 files changed, 39 insertions, 20 deletions

diff --git a/net/quic/congestion_control/fix_rate_test.cc b/net/quic/congestion_control/fix_rate_test.cc
index 33a739f..2c0770a 100644
--- a/net/quic/congestion_control/fix_rate_test.cc
+++ b/net/quic/congestion_control/fix_rate_test.cc
@@ -15,44 +15,62 @@
 namespace net {
 namespace test {
 
+class FixRateSenderPeer : public FixRateSender {
+ public:
+  explicit FixRateSenderPeer(const QuicClock* clock)
+      : FixRateSender(clock) {
+  }
+  using FixRateSender::AvailableCongestionWindow;
+};
+
+class FixRateReceiverPeer : public FixRateReceiver {
+ public:
+  FixRateReceiverPeer()
+      : FixRateReceiver() {
+  }
+  void SetBitrate(QuicBandwidth fix_rate) {
+    FixRateReceiver::configured_rate_ = fix_rate;
+  }
+};
+
 class FixRateTest : public ::testing::Test {
  protected:
   FixRateTest()
-      : rtt_(QuicTime::Delta::FromMilliseconds(30)) {
-  }
-  void SetUp() {
-    sender_.reset(new FixRateSender(&clock_));
-    receiver_.reset(new FixRateReceiver());
+      : rtt_(QuicTime::Delta::FromMilliseconds(30)),
+        sender_(new FixRateSenderPeer(&clock_)),
+        receiver_(new FixRateReceiverPeer()) {
     // Make sure clock does not start at 0.
     clock_.AdvanceTime(QuicTime::Delta::FromMilliseconds(2));
   }
   const QuicTime::Delta rtt_;
   MockClock clock_;
   SendAlgorithmInterface::SentPacketsMap not_used_;
-  scoped_ptr<FixRateSender> sender_;
-  scoped_ptr<FixRateReceiver> receiver_;
+  scoped_ptr<FixRateSenderPeer> sender_;
+  scoped_ptr<FixRateReceiverPeer> receiver_;
 };
 
 TEST_F(FixRateTest, ReceiverAPI) {
   QuicCongestionFeedbackFrame feedback;
   QuicTime timestamp(QuicTime::Zero());
-  receiver_->SetBitrate(300000);  // Bytes per second.
+  receiver_->SetBitrate(QuicBandwidth::FromKBytesPerSecond(300));
   receiver_->RecordIncomingPacket(1, 1, timestamp, false);
   ASSERT_TRUE(receiver_->GenerateCongestionFeedback(&feedback));
   EXPECT_EQ(kFixRate, feedback.type);
-  EXPECT_EQ(300000u, feedback.fix_rate.bitrate_in_bytes_per_second);
+  EXPECT_EQ(300000u, feedback.fix_rate.bitrate.ToBytesPerSecond());
 }
 
 TEST_F(FixRateTest, SenderAPI) {
   QuicCongestionFeedbackFrame feedback;
   feedback.type = kFixRate;
-  feedback.fix_rate.bitrate_in_bytes_per_second = 300000;
+  feedback.fix_rate.bitrate = QuicBandwidth::FromKBytesPerSecond(300);
   sender_->OnIncomingQuicCongestionFeedbackFrame(feedback, not_used_);
-  EXPECT_EQ(300000, sender_->BandwidthEstimate());
+  EXPECT_EQ(300000, sender_->BandwidthEstimate().ToBytesPerSecond());
   EXPECT_TRUE(sender_->TimeUntilSend(false).IsZero());
-  EXPECT_EQ(kMaxPacketSize * 2, sender_->AvailableCongestionWindow());
+  EXPECT_EQ(kMaxPacketSize * 2,
+            sender_->AvailableCongestionWindow());
   sender_->SentPacket(1, kMaxPacketSize, false);
-  EXPECT_EQ(3000u - kMaxPacketSize, sender_->AvailableCongestionWindow());
+  EXPECT_EQ(3000u - kMaxPacketSize,
+            sender_->AvailableCongestionWindow());
   EXPECT_TRUE(sender_->TimeUntilSend(false).IsZero());
   sender_->SentPacket(2, kMaxPacketSize, false);
   sender_->SentPacket(3, 600, false);
@@ -69,18 +87,19 @@ TEST_F(FixRateTest, SenderAPI) {
 }
 
 TEST_F(FixRateTest, FixRatePacing) {
-  const int64 packet_size = 1200;
-  const int64 bit_rate = 240000;
+  const QuicByteCount packet_size = 1200;
+  const QuicBandwidth bitrate = QuicBandwidth::FromKBytesPerSecond(240);
   const int64 num_packets = 200;
   QuicCongestionFeedbackFrame feedback;
-  receiver_->SetBitrate(240000);  // Bytes per second.
+  receiver_->SetBitrate(QuicBandwidth::FromKBytesPerSecond(240));
   ASSERT_TRUE(receiver_->GenerateCongestionFeedback(&feedback));
   sender_->OnIncomingQuicCongestionFeedbackFrame(feedback, not_used_);
   QuicTime acc_advance_time(QuicTime::Zero());
   QuicPacketSequenceNumber sequence_number = 0;
-  for (int i = 0; i < num_packets; i += 2) {
+  for (int64 i = 0; i < num_packets; i += 2) {
     EXPECT_TRUE(sender_->TimeUntilSend(false).IsZero());
-    EXPECT_EQ(kMaxPacketSize * 2, sender_->AvailableCongestionWindow());
+    EXPECT_EQ(kMaxPacketSize * 2,
+              sender_->AvailableCongestionWindow());
     sender_->SentPacket(sequence_number++, packet_size, false);
     EXPECT_TRUE(sender_->TimeUntilSend(false).IsZero());
     sender_->SentPacket(sequence_number++, packet_size, false);
@@ -90,8 +109,8 @@ TEST_F(FixRateTest, FixRatePacing) {
     sender_->OnIncomingAck(sequence_number - 2, packet_size, rtt_);
     acc_advance_time = acc_advance_time.Add(advance_time);
   }
-  EXPECT_EQ(num_packets * packet_size * 1000000 / bit_rate,
-            acc_advance_time.ToMicroseconds());
+  EXPECT_EQ(num_packets * packet_size * 1000000 / bitrate.ToBytesPerSecond(),
+            static_cast<uint64>(acc_advance_time.ToMicroseconds()));
 }
 
 }  // namespace test