Landing Recent QUIC changes until: Fri Oct 30 22:23:58 2015 +0000

net/quic/quic_connection_test.cc

 // Copyright (c) 2012 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/quic_connection.h"
 
 #include <ostream>
 
 #include "base/basictypes.h"
 #include "base/bind.h"
@@ skipping 437 matching lines @@
                   QuicPacket* packet,
                   QuicPacketEntropyHash entropy_hash,
                   HasRetransmittableData retransmittable,
                   bool has_ack,
                   bool has_pending_frames) {
     RetransmittableFrames* retransmittable_frames =
         retransmittable == HAS_RETRANSMITTABLE_DATA
             ? new RetransmittableFrames(ENCRYPTION_NONE)
             : nullptr;
     char buffer[kMaxPacketSize];
-    QuicEncryptedPacket* encrypted =
+    size_t encrypted_length =
         QuicConnectionPeer::GetFramer(this)->EncryptPayload(
             ENCRYPTION_NONE, packet_number, *packet, buffer, kMaxPacketSize);
     delete packet;
-    OnSerializedPacket(SerializedPacket(
-        packet_number, PACKET_6BYTE_PACKET_NUMBER, encrypted, entropy_hash,
-        retransmittable_frames, has_ack, has_pending_frames));
+    OnSerializedPacket(
+        SerializedPacket(packet_number, PACKET_6BYTE_PACKET_NUMBER, buffer,
+                         encrypted_length, false, entropy_hash,
+                         retransmittable_frames, has_ack, has_pending_frames));
   }
 
   QuicConsumedData SendStreamDataWithString(
       QuicStreamId id,
       StringPiece data,
       QuicStreamOffset offset,
       bool fin,
       QuicAckListenerInterface* listener) {
     return SendStreamDataWithStringHelper(id, data, offset, fin,
                                           MAY_FEC_PROTECT, listener);
@@ skipping 305 matching lines @@
                                     ENCRYPTION_NONE);
   }
 
   size_t ProcessDataPacketAtLevel(QuicPacketNumber number,
                                   QuicFecGroupNumber fec_group,
                                   bool entropy_flag,
                                   EncryptionLevel level) {
     scoped_ptr<QuicPacket> packet(ConstructDataPacket(number, fec_group,
                                                       entropy_flag));
     char buffer[kMaxPacketSize];
-    scoped_ptr<QuicEncryptedPacket> encrypted(
-        framer_.EncryptPayload(level, number, *packet, buffer, kMaxPacketSize));
-    connection_.ProcessUdpPacket(kSelfAddress, kPeerAddress, *encrypted);
-    return encrypted->length();
+    size_t encrypted_length =
+        framer_.EncryptPayload(level, number, *packet, buffer, kMaxPacketSize);
+    connection_.ProcessUdpPacket(
+        kSelfAddress, kPeerAddress,
+        QuicEncryptedPacket(buffer, encrypted_length, false));
+    return encrypted_length;
   }
 
   void ProcessClosePacket(QuicPacketNumber number,
                           QuicFecGroupNumber fec_group) {
     scoped_ptr<QuicPacket> packet(ConstructClosePacket(number, fec_group));
     char buffer[kMaxPacketSize];
-    scoped_ptr<QuicEncryptedPacket> encrypted(framer_.EncryptPayload(
-        ENCRYPTION_NONE, number, *packet, buffer, kMaxPacketSize));
-    connection_.ProcessUdpPacket(kSelfAddress, kPeerAddress, *encrypted);
+    size_t encrypted_length = framer_.EncryptPayload(
+        ENCRYPTION_NONE, number, *packet, buffer, kMaxPacketSize);
+    connection_.ProcessUdpPacket(
+        kSelfAddress, kPeerAddress,
+        QuicEncryptedPacket(buffer, encrypted_length, false));
   }
 
   size_t ProcessFecProtectedPacket(QuicPacketNumber number,
                                    bool expect_revival,
                                    bool entropy_flag) {
     if (expect_revival) {
       EXPECT_CALL(visitor_, OnStreamFrame(_)).Times(1);
     }
     EXPECT_CALL(visitor_, OnStreamFrame(_)).Times(1).RetiresOnSaturation();
     return ProcessDataPacket(number, 1, entropy_flag);
@@ skipping 39 matching lines @@
                header.public_header.version_flag,
                header.public_header.packet_number_length);
            i < data_packet->length(); ++i) {
         data_packet->mutable_data()[i] ^= data_packet->data()[i];
       }
     }
 
     scoped_ptr<QuicPacket> fec_packet(
         framer_.BuildFecPacket(header, data_packet->FecProtectedData()));
     char buffer[kMaxPacketSize];
-    scoped_ptr<QuicEncryptedPacket> encrypted(framer_.EncryptPayload(
-        ENCRYPTION_NONE, number, *fec_packet, buffer, kMaxPacketSize));
+    size_t encrypted_length = framer_.EncryptPayload(
+        ENCRYPTION_NONE, number, *fec_packet, buffer, kMaxPacketSize);
 
-    connection_.ProcessUdpPacket(kSelfAddress, kPeerAddress, *encrypted);
-    return encrypted->length();
+    connection_.ProcessUdpPacket(
+        kSelfAddress, kPeerAddress,
+        QuicEncryptedPacket(buffer, encrypted_length, false));
+    return encrypted_length;
   }
 
   QuicByteCount SendStreamDataToPeer(QuicStreamId id,
                                      StringPiece data,
                                      QuicStreamOffset offset,
                                      bool fin,
                                      QuicPacketNumber* last_packet) {
     QuicByteCount packet_size;
     EXPECT_CALL(*send_algorithm_, OnPacketSent(_, _, _, _, _))
         .WillOnce(DoAll(SaveArg<3>(&packet_size), Return(true)));
@@ skipping 203 matching lines @@
   header.public_header.connection_id = connection_id_;
   header.public_header.version_flag = true;
   header.packet_number = 1;
 
   QuicFrames frames;
   QuicPaddingFrame padding;
   frames.push_back(QuicFrame(&frame1_));
   frames.push_back(QuicFrame(padding));
   scoped_ptr<QuicPacket> packet(ConstructPacket(header, frames));
   char buffer[kMaxPacketSize];
-  scoped_ptr<QuicEncryptedPacket> encrypted(framer_.EncryptPayload(
-      ENCRYPTION_NONE, 12, *packet, buffer, kMaxPacketSize));
-  EXPECT_EQ(kMaxPacketSize, encrypted->length());
+  size_t encrypted_length = framer_.EncryptPayload(ENCRYPTION_NONE, 12, *packet,
+                                                   buffer, kMaxPacketSize);
+  EXPECT_EQ(kMaxPacketSize, encrypted_length);
 
   framer_.set_version(version());
   EXPECT_CALL(visitor_, OnStreamFrame(_)).Times(1);
-  connection_.ProcessUdpPacket(kSelfAddress, kPeerAddress, *encrypted);
+  connection_.ProcessUdpPacket(
+      kSelfAddress, kPeerAddress,
+      QuicEncryptedPacket(buffer, encrypted_length, false));
 
   EXPECT_EQ(kMaxPacketSize, connection_.max_packet_length());
 }
 
 TEST_P(QuicConnectionTest, IncreaseServerMaxPacketSizeWhileWriterLimited) {
   EXPECT_CALL(visitor_, OnSuccessfulVersionNegotiation(_));
 
   const QuicByteCount lower_max_packet_size = 1240;
   writer_->set_max_packet_size(lower_max_packet_size);
   connection_.set_perspective(Perspective::IS_SERVER);
   connection_.SetMaxPacketLength(1000);
   EXPECT_EQ(1000u, connection_.max_packet_length());
 
   QuicPacketHeader header;
   header.public_header.connection_id = connection_id_;
   header.public_header.version_flag = true;
   header.packet_number = 1;
 
   QuicFrames frames;
   QuicPaddingFrame padding;
   frames.push_back(QuicFrame(&frame1_));
   frames.push_back(QuicFrame(padding));
   scoped_ptr<QuicPacket> packet(ConstructPacket(header, frames));
   char buffer[kMaxPacketSize];
-  scoped_ptr<QuicEncryptedPacket> encrypted(framer_.EncryptPayload(
-      ENCRYPTION_NONE, 12, *packet, buffer, kMaxPacketSize));
-  EXPECT_EQ(kMaxPacketSize, encrypted->length());
+  size_t encrypted_length = framer_.EncryptPayload(ENCRYPTION_NONE, 12, *packet,
+                                                   buffer, kMaxPacketSize);
+  EXPECT_EQ(kMaxPacketSize, encrypted_length);
 
   framer_.set_version(version());
   EXPECT_CALL(visitor_, OnStreamFrame(_)).Times(1);
-  connection_.ProcessUdpPacket(kSelfAddress, kPeerAddress, *encrypted);
+  connection_.ProcessUdpPacket(
+      kSelfAddress, kPeerAddress,
+      QuicEncryptedPacket(buffer, encrypted_length, false));
 
   // Here, the limit imposed by the writer is lower than the size of the packet
   // received, so the writer max packet size is used.
   EXPECT_EQ(lower_max_packet_size, connection_.max_packet_length());
 }
 
 TEST_P(QuicConnectionTest, LimitMaxPacketSizeByWriter) {
   const QuicByteCount lower_max_packet_size = 1240;
   writer_->set_max_packet_size(lower_max_packet_size);
 
@@ skipping 2996 matching lines @@
 
   QuicPacketHeader header;
   header.public_header.connection_id = connection_id_;
   header.public_header.version_flag = true;
   header.packet_number = 12;
 
   QuicFrames frames;
   frames.push_back(QuicFrame(&frame1_));
   scoped_ptr<QuicPacket> packet(ConstructPacket(header, frames));
   char buffer[kMaxPacketSize];
-  scoped_ptr<QuicEncryptedPacket> encrypted(framer_.EncryptPayload(
-      ENCRYPTION_NONE, 12, *packet, buffer, kMaxPacketSize));
+  size_t encrypted_length = framer_.EncryptPayload(ENCRYPTION_NONE, 12, *packet,
+                                                   buffer, kMaxPacketSize);
 
   framer_.set_version(version());
   connection_.set_perspective(Perspective::IS_SERVER);
-  connection_.ProcessUdpPacket(kSelfAddress, kPeerAddress, *encrypted);
+  connection_.ProcessUdpPacket(
+      kSelfAddress, kPeerAddress,
+      QuicEncryptedPacket(buffer, encrypted_length, false));
   EXPECT_TRUE(writer_->version_negotiation_packet() != nullptr);
 
   size_t num_versions = arraysize(kSupportedQuicVersions);
   ASSERT_EQ(num_versions,
             writer_->version_negotiation_packet()->versions.size());
 
   // We expect all versions in kSupportedQuicVersions to be
   // included in the packet.
   for (size_t i = 0; i < num_versions; ++i) {
     EXPECT_EQ(kSupportedQuicVersions[i],
               writer_->version_negotiation_packet()->versions[i]);
   }
 }
 
 TEST_P(QuicConnectionTest, ServerSendsVersionNegotiationPacketSocketBlocked) {
   connection_.SetSupportedVersions(QuicSupportedVersions());
   framer_.set_version_for_tests(QUIC_VERSION_UNSUPPORTED);
 
   QuicPacketHeader header;
   header.public_header.connection_id = connection_id_;
   header.public_header.version_flag = true;
   header.packet_number = 12;
 
   QuicFrames frames;
   frames.push_back(QuicFrame(&frame1_));
   scoped_ptr<QuicPacket> packet(ConstructPacket(header, frames));
   char buffer[kMaxPacketSize];
-  scoped_ptr<QuicEncryptedPacket> encrypted(framer_.EncryptPayload(
-      ENCRYPTION_NONE, 12, *packet, buffer, kMaxPacketSize));
+  size_t encrypted_length = framer_.EncryptPayload(ENCRYPTION_NONE, 12, *packet,
+                                                   buffer, kMaxPacketSize);
 
   framer_.set_version(version());
   connection_.set_perspective(Perspective::IS_SERVER);
   BlockOnNextWrite();
-  connection_.ProcessUdpPacket(kSelfAddress, kPeerAddress, *encrypted);
+  connection_.ProcessUdpPacket(
+      kSelfAddress, kPeerAddress,
+      QuicEncryptedPacket(buffer, encrypted_length, false));
   EXPECT_EQ(0u, writer_->last_packet_size());
   EXPECT_TRUE(connection_.HasQueuedData());
 
   writer_->SetWritable();
   connection_.OnCanWrite();
   EXPECT_TRUE(writer_->version_negotiation_packet() != nullptr);
 
   size_t num_versions = arraysize(kSupportedQuicVersions);
   ASSERT_EQ(num_versions,
             writer_->version_negotiation_packet()->versions.size());
@@ skipping 13 matching lines @@
 
   QuicPacketHeader header;
   header.public_header.connection_id = connection_id_;
   header.public_header.version_flag = true;
   header.packet_number = 12;
 
   QuicFrames frames;
   frames.push_back(QuicFrame(&frame1_));
   scoped_ptr<QuicPacket> packet(ConstructPacket(header, frames));
   char buffer[kMaxPacketSize];
-  scoped_ptr<QuicEncryptedPacket> encrypted(framer_.EncryptPayload(
-      ENCRYPTION_NONE, 12, *packet, buffer, kMaxPacketSize));
+  size_t encryped_length = framer_.EncryptPayload(ENCRYPTION_NONE, 12, *packet,
+                                                  buffer, kMaxPacketSize);
 
   framer_.set_version(version());
   connection_.set_perspective(Perspective::IS_SERVER);
   BlockOnNextWrite();
   writer_->set_is_write_blocked_data_buffered(true);
-  connection_.ProcessUdpPacket(kSelfAddress, kPeerAddress, *encrypted);
+  connection_.ProcessUdpPacket(
+      kSelfAddress, kPeerAddress,
+      QuicEncryptedPacket(buffer, encryped_length, false));
   EXPECT_EQ(0u, writer_->last_packet_size());
   EXPECT_FALSE(connection_.HasQueuedData());
 }
 
 TEST_P(QuicConnectionTest, ClientHandlesVersionNegotiation) {
   // Start out with some unsupported version.
   QuicConnectionPeer::GetFramer(&connection_)->set_version_for_tests(
       QUIC_VERSION_UNSUPPORTED);
 
   QuicPacketHeader header;
@@ skipping 12 matching lines @@
           header.public_header, supported_versions));
   connection_.ProcessUdpPacket(kSelfAddress, kPeerAddress, *encrypted);
 
   // Now force another packet.  The connection should transition into
   // NEGOTIATED_VERSION state and tell the packet creator to StopSendingVersion.
   header.public_header.version_flag = false;
   QuicFrames frames;
   frames.push_back(QuicFrame(&frame1_));
   scoped_ptr<QuicPacket> packet(ConstructPacket(header, frames));
   char buffer[kMaxPacketSize];
-  encrypted.reset(framer_.EncryptPayload(ENCRYPTION_NONE, 12, *packet, buffer,
-                                         kMaxPacketSize));
+  size_t encrypted_length = framer_.EncryptPayload(ENCRYPTION_NONE, 12, *packet,
+                                                   buffer, kMaxPacketSize);
+  ASSERT_NE(0u, encrypted_length);
   EXPECT_CALL(visitor_, OnStreamFrame(_)).Times(1);
   EXPECT_CALL(visitor_, OnSuccessfulVersionNegotiation(_));
-  connection_.ProcessUdpPacket(kSelfAddress, kPeerAddress, *encrypted);
+  connection_.ProcessUdpPacket(
+      kSelfAddress, kPeerAddress,
+      QuicEncryptedPacket(buffer, encrypted_length, false));
 
   ASSERT_FALSE(QuicPacketCreatorPeer::SendVersionInPacket(creator_));
 }
 
 TEST_P(QuicConnectionTest, BadVersionNegotiation) {
   QuicPacketHeader header;
   header.public_header.connection_id = connection_id_;
   header.public_header.version_flag = true;
   header.packet_number = 12;
 
@@ skipping 110 matching lines @@
 
   QuicConnectionCloseFrame qccf;
   qccf.error_code = QUIC_PEER_GOING_AWAY;
 
   QuicFrames frames;
   frames.push_back(QuicFrame(&frame1_));
   frames.push_back(QuicFrame(&qccf));
   scoped_ptr<QuicPacket> packet(ConstructPacket(header, frames));
   EXPECT_TRUE(nullptr != packet.get());
   char buffer[kMaxPacketSize];
-  scoped_ptr<QuicEncryptedPacket> encrypted(framer_.EncryptPayload(
-      ENCRYPTION_NONE, 1, *packet, buffer, kMaxPacketSize));
+  size_t encrypted_length = framer_.EncryptPayload(ENCRYPTION_NONE, 1, *packet,
+                                                   buffer, kMaxPacketSize);
 
   EXPECT_CALL(visitor_, OnConnectionClosed(QUIC_PEER_GOING_AWAY, true));
   EXPECT_CALL(visitor_, OnStreamFrame(_)).Times(1);
   EXPECT_CALL(visitor_, OnSuccessfulVersionNegotiation(_));
 
-  connection_.ProcessUdpPacket(kSelfAddress, kPeerAddress, *encrypted);
+  connection_.ProcessUdpPacket(
+      kSelfAddress, kPeerAddress,
+      QuicEncryptedPacket(buffer, encrypted_length, false));
 }
 
 TEST_P(QuicConnectionTest, SelectMutualVersion) {
   connection_.SetSupportedVersions(QuicSupportedVersions());
   // Set the connection to speak the lowest quic version.
   connection_.set_version(QuicVersionMin());
   EXPECT_EQ(QuicVersionMin(), connection_.version());
 
   // Pass in available versions which includes a higher mutually supported
   // version.  The higher mutually supported version should be selected.
@@ skipping 213 matching lines @@
   EXPECT_CALL(*listener, OnPacketAcked(_, _)).Times(1);
   // Send some data, which will register the listener to be notified.
   connection_.SendStreamDataWithString(1, "foo", 0, !kFin, listener.get());
   connection_.SendStreamDataWithString(2, "bar", 0, !kFin, nullptr);
 
   // Process an ACK from the server with a revived packet, which should trigger
   // the callback.
   EXPECT_CALL(*send_algorithm_, OnCongestionEvent(true, _, _, _));
   QuicAckFrame frame = InitAckFrame(2);
   NackPacket(1, &frame);
-  frame.revived_packets.insert(1);
+  frame.latest_revived_packet = 1;
   ProcessAckPacket(&frame);
   // If the ack is processed again, the notifier should not be called again.
   ProcessAckPacket(&frame);
 }
 
 TEST_P(QuicConnectionTest, AckNotifierCallbackAfterFECRecovery) {
   EXPECT_CALL(visitor_, OnSuccessfulVersionNegotiation(_));
   EXPECT_CALL(visitor_, OnCanWrite());
 
   // Create a listener which we expect to be called.
@@ skipping 175 matching lines @@
   EXPECT_CALL(*send_algorithm_, OnPacketSent(_, _, _, _, _)).Times(1);
   connection_.SendGoAway(QUIC_PEER_GOING_AWAY, kHeadersStreamId, "Going Away.");
   EXPECT_TRUE(connection_.goaway_sent());
   EXPECT_CALL(*send_algorithm_, OnPacketSent(_, _, _, _, _)).Times(0);
   connection_.SendGoAway(QUIC_PEER_GOING_AWAY, kHeadersStreamId, "Going Away.");
 }
 
 }  // namespace
 }  // namespace test
 }  // namespace net