Land Recent QUIC changes.

Pass HasRetransmittableData to the congestion manager and the send
algorithm. This allows tcp_cubic_sender to not count ACK-only packets
against the congestion window.

Merge internal change: 51829697

If a previously zombie'd QUIC stream is closed and the headers have been
decompressed, remove that entry from the zombie stream map.

Merge internal change: 51697989

Change the value used to set the sequence number with to both correctly
calculate the widest packet spread currently outstanding and fix a
DCHECK failure in EndToEnd's Uber test when packets were transmitted
sufficiently out of order that the packet being sent was less than the
last packet the peer was awaiting.

Merge internal change: 51644967

Fix a bug where frames are queued and not enough room for the next
stream frame is available, but we attempt to create a STREAM frame
anyway in ConsumeData.

Merge internal change: 51604946

Changed Delayed Ack Timer to go off before the sender's retransmission
timer goes off.

Merge internal change: 51594956

Using the priorities sent by the client, including bounds checking,
and bumping the priority of initial writes to avoid the HOL header
blocking issue.

Merge internal change: 51586426

Fix memory leak uncovered by https://codereview.chromium.org/23587004

Merge internal change: 51569066

Added logging of QUIC version negotiated.

Export number of QUIC sessions and streams for each QUIC version.

Merge internal change: 51540178

A refactor of QuicFdWrapper's writev to pass the iovec all the way to
QuicConnection, allowing better packet packing.

Merge internal change: 51530908

Enabled priorities in chrome quic streams.

R=rch@chromium.org

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

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

5 files changed, 53 insertions, 26 deletions

diff --git a/net/tools/quic/quic_epoll_connection_helper_test.cc b/net/tools/quic/quic_epoll_connection_helper_test.cc
index 6d6ea13..9f0321a 100644
--- a/net/tools/quic/quic_epoll_connection_helper_test.cc
+++ b/net/tools/quic/quic_epoll_connection_helper_test.cc
@@ -91,6 +91,8 @@ class QuicEpollConnectionHelperTest : public ::testing::Test {
         QuicBandwidth::FromKBitsPerSecond(100)));
     EXPECT_CALL(*send_algorithm_, SmoothedRtt()).WillRepeatedly(Return(
         QuicTime::Delta::FromMilliseconds(100)));
+    ON_CALL(*send_algorithm_, SentPacket(_, _, _, _, _))
+        .WillByDefault(Return(true));
   }
 
   QuicPacket* ConstructDataPacket(QuicPacketSequenceNumber number,
@@ -136,12 +138,14 @@ TEST_F(QuicEpollConnectionHelperTest, DISABLED_TestRetransmission) {
       arraysize(buffer) - 1;
 
   EXPECT_CALL(*send_algorithm_,
-              SentPacket(_, 1, packet_size, NOT_RETRANSMISSION));
+              SentPacket(_, 1, packet_size, NOT_RETRANSMISSION, _));
   EXPECT_CALL(*send_algorithm_, AbandoningPacket(1, packet_size));
-  connection_.SendStreamData(1, buffer, 0, false);
+  struct iovec iov = {const_cast<char*>(buffer),
+                      static_cast<size_t>(3)};
+  connection_.SendvStreamData(1, &iov, 1, 0, false);
   EXPECT_EQ(1u, helper_->header()->packet_sequence_number);
   EXPECT_CALL(*send_algorithm_,
-              SentPacket(_, 2, packet_size, IS_RETRANSMISSION));
+              SentPacket(_, 2, packet_size, IS_RETRANSMISSION, _));
   epoll_server_.AdvanceByAndCallCallbacks(kDefaultRetransmissionTimeMs * 1000);
 
   EXPECT_EQ(2u, helper_->header()->packet_sequence_number);
@@ -150,7 +154,7 @@ TEST_F(QuicEpollConnectionHelperTest, DISABLED_TestRetransmission) {
 TEST_F(QuicEpollConnectionHelperTest, InitialTimeout) {
   EXPECT_TRUE(connection_.connected());
 
-  EXPECT_CALL(*send_algorithm_, SentPacket(_, 1, _, NOT_RETRANSMISSION));
+  EXPECT_CALL(*send_algorithm_, SentPacket(_, 1, _, NOT_RETRANSMISSION, _));
   EXPECT_CALL(visitor_, ConnectionClose(QUIC_CONNECTION_TIMED_OUT, !kFromPeer));
   epoll_server_.WaitForEventsAndExecuteCallbacks();
   EXPECT_FALSE(connection_.connected());
@@ -167,7 +171,8 @@ TEST_F(QuicEpollConnectionHelperTest, TimeoutAfterSend) {
   EXPECT_EQ(5000, epoll_server_.NowInUsec());
 
   // Send an ack so we don't set the retransmission alarm.
-  EXPECT_CALL(*send_algorithm_, SentPacket(_, 1, _, NOT_RETRANSMISSION));
+  EXPECT_CALL(*send_algorithm_,
+              SentPacket(_, 1, _, NOT_RETRANSMISSION, NO_RETRANSMITTABLE_DATA));
   connection_.SendAck();
 
   // The original alarm will fire.  We should not time out because we had a
@@ -177,7 +182,8 @@ TEST_F(QuicEpollConnectionHelperTest, TimeoutAfterSend) {
 
   // This time, we should time out.
   EXPECT_CALL(visitor_, ConnectionClose(QUIC_CONNECTION_TIMED_OUT, !kFromPeer));
-  EXPECT_CALL(*send_algorithm_, SentPacket(_, 2, _, NOT_RETRANSMISSION));
+  EXPECT_CALL(*send_algorithm_,
+              SentPacket(_, 2, _, NOT_RETRANSMISSION, NO_RETRANSMITTABLE_DATA));
   epoll_server_.WaitForEventsAndExecuteCallbacks();
   EXPECT_EQ(kDefaultInitialTimeoutSecs * 1000000 + 5000,
             epoll_server_.NowInUsec());
@@ -191,17 +197,19 @@ TEST_F(QuicEpollConnectionHelperTest, SendSchedulerDelayThenSend) {
   QuicPacket* packet = ConstructDataPacket(1, 0);
   EXPECT_CALL(
       *send_algorithm_, TimeUntilSend(_, NOT_RETRANSMISSION, _, _)).WillOnce(
-          testing::Return(QuicTime::Delta::FromMicroseconds(1)));
+          Return(QuicTime::Delta::FromMicroseconds(1)));
   connection_.SendOrQueuePacket(ENCRYPTION_NONE, 1, packet, 0,
                                 HAS_RETRANSMITTABLE_DATA);
-  EXPECT_CALL(*send_algorithm_, SentPacket(_, 1, _, NOT_RETRANSMISSION));
+  EXPECT_CALL(*send_algorithm_, SentPacket(_, 1, _, NOT_RETRANSMISSION,
+                                           _));
   EXPECT_EQ(1u, connection_.NumQueuedPackets());
 
   // Advance the clock to fire the alarm, and configure the scheduler
   // to permit the packet to be sent.
-  EXPECT_CALL(*send_algorithm_, TimeUntilSend(_, NOT_RETRANSMISSION, _, _)).
-      WillRepeatedly(testing::Return(QuicTime::Delta::Zero()));
-  EXPECT_CALL(visitor_, OnCanWrite()).WillOnce(testing::Return(true));
+  EXPECT_CALL(*send_algorithm_,
+              TimeUntilSend(_, NOT_RETRANSMISSION, _, _)).WillRepeatedly(
+      Return(QuicTime::Delta::Zero()));
+  EXPECT_CALL(visitor_, OnCanWrite()).WillOnce(Return(true));
   epoll_server_.AdvanceByAndCallCallbacks(1);
   EXPECT_EQ(0u, connection_.NumQueuedPackets());
 }
diff --git a/net/tools/quic/quic_reliable_server_stream_test.cc b/net/tools/quic/quic_reliable_server_stream_test.cc
index b946d94..8e4ae4c 100644
--- a/net/tools/quic/quic_reliable_server_stream_test.cc
+++ b/net/tools/quic/quic_reliable_server_stream_test.cc
@@ -58,7 +58,9 @@ class QuicReliableServerStreamTest : public ::testing::Test {
     stream_.reset(new QuicSpdyServerStream(3, &session_));
   }
 
-  QuicConsumedData ValidateHeaders(StringPiece headers) {
+  QuicConsumedData ValidateHeaders(const struct iovec* iov) {
+    StringPiece headers =
+        StringPiece(static_cast<const char*>(iov[0].iov_base), iov[0].iov_len);
     headers_string_ = SpdyUtils::SerializeResponseHeaders(
         response_headers_);
     QuicSpdyDecompressor decompressor;
@@ -119,13 +121,17 @@ class QuicReliableServerStreamTest : public ::testing::Test {
   string body_;
 };
 
-QuicConsumedData ConsumeAllData(QuicStreamId id, StringPiece data,
-                                QuicStreamOffset offset, bool fin) {
-  return QuicConsumedData(data.size(), fin);
+QuicConsumedData ConsumeAllData(QuicStreamId id, const struct iovec* iov,
+                                int count, QuicStreamOffset offset, bool fin) {
+  ssize_t consumed_length = 0;
+  for (int i = 0; i < count; ++i) {
+    consumed_length += iov[i].iov_len;
+  }
+  return QuicConsumedData(consumed_length, fin);
 }
 
 TEST_F(QuicReliableServerStreamTest, TestFraming) {
-  EXPECT_CALL(session_, WriteData(_, _, _, _)).Times(AnyNumber()).
+  EXPECT_CALL(session_, WritevData(_, _, _, _, _)).Times(AnyNumber()).
       WillRepeatedly(Invoke(ConsumeAllData));
 
   EXPECT_EQ(headers_string_.size(), stream_->ProcessData(
@@ -138,7 +144,7 @@ TEST_F(QuicReliableServerStreamTest, TestFraming) {
 }
 
 TEST_F(QuicReliableServerStreamTest, TestFramingOnePacket) {
-  EXPECT_CALL(session_, WriteData(_, _, _, _)).Times(AnyNumber()).
+  EXPECT_CALL(session_, WritevData(_, _, _, _, _)).Times(AnyNumber()).
       WillRepeatedly(Invoke(ConsumeAllData));
 
   string message = headers_string_ + body_;
@@ -156,7 +162,7 @@ TEST_F(QuicReliableServerStreamTest, TestFramingExtraData) {
   string large_body = "hello world!!!!!!";
 
   // We'll automatically write out an error (headers + body)
-  EXPECT_CALL(session_, WriteData(_, _, _, _)).Times(2).
+  EXPECT_CALL(session_, WritevData(_, _, _, _, _)).Times(2).
       WillRepeatedly(Invoke(ConsumeAllData));
 
   EXPECT_EQ(headers_string_.size(), stream_->ProcessData(
@@ -183,11 +189,11 @@ TEST_F(QuicReliableServerStreamTest, TestSendResponse) {
   response_headers_.ReplaceOrAppendHeader("content-length", "3");
 
   InSequence s;
-  EXPECT_CALL(session_, WriteData(_, _, _, _)).Times(1)
+  EXPECT_CALL(session_, WritevData(_, _, 1, _, _)).Times(1)
       .WillOnce(WithArgs<1>(Invoke(
           this, &QuicReliableServerStreamTest::ValidateHeaders)));
-  StringPiece kBody = "Yum";
-  EXPECT_CALL(session_, WriteData(_, kBody, _, _)).Times(1).
+
+  EXPECT_CALL(session_, WritevData(_, _, 1, _, _)).Times(1).
       WillOnce(Return(QuicConsumedData(3, true)));
 
   stream_->SendResponse();
@@ -201,11 +207,11 @@ TEST_F(QuicReliableServerStreamTest, TestSendErrorResponse) {
   response_headers_.ReplaceOrAppendHeader("content-length", "3");
 
   InSequence s;
-  EXPECT_CALL(session_, WriteData(_, _, _, _)).Times(1)
+  EXPECT_CALL(session_, WritevData(_, _, 1, _, _)).Times(1)
       .WillOnce(WithArgs<1>(Invoke(
           this, &QuicReliableServerStreamTest::ValidateHeaders)));
-  StringPiece kBody = "bad";
-  EXPECT_CALL(session_, WriteData(_, kBody, _, _)).Times(1).
+
+  EXPECT_CALL(session_, WritevData(_, _, 1, _, _)).Times(1).
       WillOnce(Return(QuicConsumedData(3, true)));
 
   stream_->SendErrorResponse();
diff --git a/net/tools/quic/quic_spdy_client_stream.h b/net/tools/quic/quic_spdy_client_stream.h
index ec4d257..5d32b30 100644
--- a/net/tools/quic/quic_spdy_client_stream.h
+++ b/net/tools/quic/quic_spdy_client_stream.h
@@ -34,6 +34,10 @@ class QuicSpdyClientStream : public QuicReliableClientStream {
                               base::StringPiece body,
                               bool fin) OVERRIDE;
 
+  // While the server's set_priority shouldn't be called externally, the creator
+  // of client-side streams should be able to set the priority.
+  using QuicReliableClientStream::set_priority;
+
  private:
   int ParseResponseHeaders();
 
diff --git a/net/tools/quic/test_tools/quic_test_client.cc b/net/tools/quic/test_tools/quic_test_client.cc
index 03600f2..272786e 100644
--- a/net/tools/quic/test_tools/quic_test_client.cc
+++ b/net/tools/quic/test_tools/quic_test_client.cc
@@ -11,6 +11,7 @@
 #include "net/quic/crypto/proof_verifier.h"
 #include "net/tools/flip_server/balsa_headers.h"
 #include "net/tools/quic/quic_epoll_connection_helper.h"
+#include "net/tools/quic/quic_spdy_client_stream.h"
 #include "net/tools/quic/test_tools/http_message_test_utils.h"
 #include "url/gurl.h"
 
@@ -157,6 +158,7 @@ void QuicTestClient::Initialize(IPEndPoint address,
   server_address_ = address;
   stream_ = NULL;
   stream_error_ = QUIC_STREAM_NO_ERROR;
+  priority_ = 3;
   bytes_read_ = 0;
   bytes_written_= 0;
   never_connected_ = true;
@@ -243,10 +245,13 @@ QuicReliableClientStream* QuicTestClient::GetOrCreateStream() {
   }
   if (!stream_) {
     stream_ = client_->CreateReliableClientStream();
-    if (stream_ != NULL) {
-      stream_->set_visitor(this);
+    if (stream_ == NULL) {
+      return NULL;
     }
+    stream_->set_visitor(this);
+    reinterpret_cast<QuicSpdyClientStream*>(stream_)->set_priority(priority_);
   }
+
   return stream_;
 }
 
diff --git a/net/tools/quic/test_tools/quic_test_client.h b/net/tools/quic/test_tools/quic_test_client.h
index 74bfc24..3cd71d5 100644
--- a/net/tools/quic/test_tools/quic_test_client.h
+++ b/net/tools/quic/test_tools/quic_test_client.h
@@ -107,6 +107,8 @@ class QuicTestClient :  public ReliableQuicStream::Visitor {
 
   void set_auto_reconnect(bool reconnect) { auto_reconnect_ = reconnect; }
 
+  void set_priority(QuicPriority priority) { priority_ = priority; }
+
  private:
   void Initialize(IPEndPoint address, const string& hostname, bool secure);
 
@@ -118,6 +120,8 @@ class QuicTestClient :  public ReliableQuicStream::Visitor {
   QuicRstStreamErrorCode stream_error_;
 
   BalsaHeaders headers_;
+  QuicPriority priority_;
+
   string response_;
   uint64 bytes_read_;
   uint64 bytes_written_;