Land Recent QUIC Changes.

These LOG(INFO)s claimed 8-9% of time under a load test.

Reduce logspam in QuicUnackedPacketMap.

Merge internal change: 61895796
https://codereview.chromium.org/179773007/


QUIC WINDOW_UPDATE and BLOCKED frames instigate ACKs.

Merge internal change: 61894847
https://codereview.chromium.org/180013004/


Avoiding quic double-close bugs by detecting it at the connection.

Merge internal change: 61890466
https://codereview.chromium.org/180793003/


BLOCKED frames not being cleared. These are not yet used.

(minor) Clear last BLOCKED frames in QuicConnection

Merge internal change: 61875848
https://codereview.chromium.org/180793002/


QUIC - minor cleanup while merging internal change.

Merge internal change: 61850595
https://codereview.chromium.org/177073016/


Create QUIC_VERSION_16 which breaks the sent_info field out of the ACK
frame into a new STOP_WAITING frame.  Does not change when this
information is sent.  That will happen in a follow-up CL.

Send STOP_WAITING_FRAME for QUIC version 16 and above with Ack frame.
Added logging for WINDOW_UPDATE and BLOCKED frames.

Merge internal change: 61838258
https://codereview.chromium.org/180383004/


QUIC test refactor to move tests from the QuicSentPacketManagerTest to
the new TcpLossAlgorithmTest.

Merge internal change: 61837708
https://codereview.chromium.org/177203008/


Ctrl-F for "packet XY" in debug logs now matches sent packets "Sending
packet XY", and received packets "Got packet XY".

(minor) Improve QUIC packet sent debug log message

Merge internal change: 61836667
https://codereview.chromium.org/177003007/


Auotmated rollback of internal changelist 57996291.

*** Reason for rollback ***

Now that clients no longer suggests 100 by default, it would be nice to
experiment with allowing the client to suggest larger CWNDs.

*** Original change description ***

Temporarily change the maximum server initial congestion window to 10
from 100, because many existing Chrome clients are still negotiating
100, causing visible performance issues, particularly for YouTube
rebuffers.

***

Merge internal change: 61825277
https://codereview.chromium.org/178853003/


Refactor to create a new LossDetectionInterface used by the
QuicSentPacketManager.

Merge internal change: 61813052
https://codereview.chromium.org/178453005/


Preparation for only writing a fraction of the iov due to flow control
blocking in ReliableQuicStream::WritevData.

Add max_bytes argument to QuicSession::WritevData

Merge internal change: 61810929
https://codereview.chromium.org/177203006/

R=rch@chromium.org

Review URL: https://codereview.chromium.org/180723003

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

1 files changed, 147 insertions, 0 deletions

diff --git a/net/quic/congestion_control/tcp_loss_algorithm_test.cc b/net/quic/congestion_control/tcp_loss_algorithm_test.cc
new file mode 100644
index 0000000..d2737df
--- /dev/null
+++ b/net/quic/congestion_control/tcp_loss_algorithm_test.cc
@@ -0,0 +1,147 @@
+// 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 "net/quic/congestion_control/tcp_loss_algorithm.h"
+
+#include <algorithm>
+
+#include "base/logging.h"
+#include "base/stl_util.h"
+#include "net/quic/quic_unacked_packet_map.h"
+#include "testing/gtest/include/gtest/gtest.h"
+
+namespace net {
+namespace test {
+namespace {
+
+class TcpLossAlgorithmTest : public ::testing::Test {
+ protected:
+  TcpLossAlgorithmTest()
+      : unacked_packets_(true),
+        srtt_(QuicTime::Delta::FromMilliseconds(10)) { }
+
+  void SendDataPacket(QuicPacketSequenceNumber sequence_number) {
+    SerializedPacket packet(sequence_number, PACKET_1BYTE_SEQUENCE_NUMBER,
+                            NULL, 0, new RetransmittableFrames());
+    unacked_packets_.AddPacket(packet);
+    unacked_packets_.SetPending(sequence_number, QuicTime::Zero(), 1000);
+  }
+
+  void VerifyLosses(QuicPacketSequenceNumber largest_observed,
+                    QuicPacketSequenceNumber* losses_expected,
+                    size_t num_losses) {
+    SequenceNumberSet lost_packets =
+        loss_algorithm_.DetectLostPackets(
+            unacked_packets_, QuicTime::Zero(), largest_observed, srtt_);
+    EXPECT_EQ(num_losses, lost_packets.size());
+    for (size_t i = 0; i < num_losses; ++i) {
+      EXPECT_TRUE(ContainsKey(lost_packets, losses_expected[i]));
+    }
+  }
+
+  QuicUnackedPacketMap unacked_packets_;
+  TCPLossAlgorithm loss_algorithm_;
+  QuicTime::Delta srtt_;
+};
+
+TEST_F(TcpLossAlgorithmTest, NackRetransmit1Packet) {
+  const size_t kNumSentPackets = 5;
+  // Transmit 5 packets.
+  for (size_t i = 1; i <= kNumSentPackets; ++i) {
+    SendDataPacket(i);
+  }
+  // No loss on one ack.
+  unacked_packets_.SetNotPending(2);
+  unacked_packets_.NackPacket(1, 1);
+  VerifyLosses(2, NULL, 0);
+  // No loss on two acks.
+  unacked_packets_.SetNotPending(3);
+  unacked_packets_.NackPacket(1, 2);
+  VerifyLosses(3, NULL, 0);
+  // Loss on three acks.
+  unacked_packets_.SetNotPending(4);
+  unacked_packets_.NackPacket(1, 3);
+  QuicPacketSequenceNumber lost[] = { 1 };
+  VerifyLosses(4, lost, arraysize(lost));
+}
+
+// A stretch ack is an ack that covers more than 1 packet of previously
+// unacknowledged data.
+TEST_F(TcpLossAlgorithmTest, NackRetransmit1PacketWith1StretchAck) {
+  const size_t kNumSentPackets = 10;
+  // Transmit 10 packets.
+  for (size_t i = 1; i <= kNumSentPackets; ++i) {
+    SendDataPacket(i);
+  }
+
+  // Nack the first packet 3 times in a single StretchAck.
+  unacked_packets_.NackPacket(1, 3);
+  unacked_packets_.SetNotPending(2);
+  unacked_packets_.SetNotPending(3);
+  unacked_packets_.SetNotPending(4);
+  QuicPacketSequenceNumber lost[] = { 1 };
+  VerifyLosses(4, lost, arraysize(lost));
+}
+
+// Ack a packet 3 packets ahead, causing a retransmit.
+TEST_F(TcpLossAlgorithmTest, NackRetransmit1PacketSingleAck) {
+  const size_t kNumSentPackets = 10;
+  // Transmit 10 packets.
+  for (size_t i = 1; i <= kNumSentPackets; ++i) {
+    SendDataPacket(i);
+  }
+
+  // Nack the first packet 3 times in an AckFrame with three missing packets.
+  unacked_packets_.NackPacket(1, 3);
+  unacked_packets_.NackPacket(2, 2);
+  unacked_packets_.NackPacket(3, 1);
+  unacked_packets_.SetNotPending(4);
+  QuicPacketSequenceNumber lost[] = { 1 };
+  VerifyLosses(4, lost, arraysize(lost));
+}
+
+TEST_F(TcpLossAlgorithmTest, EarlyRetransmit1Packet) {
+  const size_t kNumSentPackets = 2;
+  // Transmit 2 packets.
+  for (size_t i = 1; i <= kNumSentPackets; ++i) {
+    SendDataPacket(i);
+  }
+  // Early retransmit when the final packet gets acked and the first is nacked.
+  unacked_packets_.SetNotPending(2);
+  unacked_packets_.NackPacket(1, 1);
+  QuicPacketSequenceNumber lost[] = { 1 };
+  VerifyLosses(2, lost, arraysize(lost));
+}
+
+TEST_F(TcpLossAlgorithmTest, EarlyRetransmitAllPackets) {
+  const size_t kNumSentPackets = 5;
+  for (size_t i = 1; i <= kNumSentPackets; ++i) {
+    SendDataPacket(i);
+  }
+  // Early retransmit when the final packet gets acked and the first 4 are
+  // nacked multiple times via FACK.
+  unacked_packets_.SetNotPending(kNumSentPackets);
+  for (size_t i = 1; i < kNumSentPackets; ++i) {
+    unacked_packets_.NackPacket(i, kNumSentPackets - i);
+  }
+  QuicPacketSequenceNumber lost[] = { 1, 2, 3, 4 };
+  VerifyLosses(kNumSentPackets, lost, arraysize(lost));
+}
+
+TEST_F(TcpLossAlgorithmTest, DontEarlyRetransmitNeuteredPacket) {
+  const size_t kNumSentPackets = 2;
+  // Transmit 2 packets.
+  for (size_t i = 1; i <= kNumSentPackets; ++i) {
+    SendDataPacket(i);
+  }
+  // Early retransmit when the final packet gets acked and the first is nacked.
+  unacked_packets_.SetNotPending(2);
+  unacked_packets_.NackPacket(1, 1);
+  unacked_packets_.NeuterPacket(1);
+  VerifyLosses(2, NULL, 0);
+}
+
+}  // namespace
+}  // namespace test
+}  // namespace net