Landing recent QUIC changes until 6/24/2016 14:00 UTC

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 <errno.h>
 #include <memory>
 #include <ostream>
 #include <utility>
@@ skipping 1593 matching lines @@
 
 TEST_P(QuicConnectionTest, AckAll) {
   EXPECT_CALL(visitor_, OnSuccessfulVersionNegotiation(_));
   ProcessPacket(kDefaultPathId, 1);
 
   QuicPacketCreatorPeer::SetPacketNumber(&peer_creator_, 1);
   QuicAckFrame frame1 = InitAckFrame(0);
   ProcessAckPacket(&frame1);
 }
 
-TEST_P(QuicConnectionTest, SendingDifferentSequenceNumberLengthsBandwidth) {
-  QuicPacketNumber last_packet;
-  SendStreamDataToPeer(1, "foo", 0, !kFin, &last_packet);
-  EXPECT_EQ(1u, last_packet);
-  EXPECT_EQ(PACKET_1BYTE_PACKET_NUMBER,
-            QuicPacketCreatorPeer::NextPacketNumberLength(creator_));
-  EXPECT_EQ(PACKET_1BYTE_PACKET_NUMBER,
-            writer_->header().public_header.packet_number_length);
-
-  EXPECT_CALL(*send_algorithm_, GetCongestionWindow())
-      .WillRepeatedly(Return(kMaxPacketSize * 256));
-
-  SendStreamDataToPeer(1, "bar", 3, !kFin, &last_packet);
-  EXPECT_EQ(2u, last_packet);
-  EXPECT_EQ(PACKET_2BYTE_PACKET_NUMBER,
-            QuicPacketCreatorPeer::NextPacketNumberLength(creator_));
-  // The 1 packet lag is due to the packet number length being recalculated in
-  // QuicConnection after a packet is sent.
-  EXPECT_EQ(PACKET_1BYTE_PACKET_NUMBER,
-            writer_->header().public_header.packet_number_length);
-
-  EXPECT_CALL(*send_algorithm_, GetCongestionWindow())
-      .WillRepeatedly(Return(kMaxPacketSize * 256 * 256));
-
-  SendStreamDataToPeer(1, "foo", 6, !kFin, &last_packet);
-  EXPECT_EQ(3u, last_packet);
-  EXPECT_EQ(PACKET_4BYTE_PACKET_NUMBER,
-            QuicPacketCreatorPeer::NextPacketNumberLength(creator_));
-  EXPECT_EQ(PACKET_2BYTE_PACKET_NUMBER,
-            writer_->header().public_header.packet_number_length);
-
-  EXPECT_CALL(*send_algorithm_, GetCongestionWindow())
-      .WillRepeatedly(Return(kMaxPacketSize * 256 * 256 * 256));
-
-  SendStreamDataToPeer(1, "bar", 9, !kFin, &last_packet);
-  EXPECT_EQ(4u, last_packet);
-  EXPECT_EQ(PACKET_4BYTE_PACKET_NUMBER,
-            QuicPacketCreatorPeer::NextPacketNumberLength(creator_));
-  EXPECT_EQ(PACKET_4BYTE_PACKET_NUMBER,
-            writer_->header().public_header.packet_number_length);
-
-  EXPECT_CALL(*send_algorithm_, GetCongestionWindow())
-      .WillRepeatedly(Return(kMaxPacketSize * 256 * 256 * 256 * 256));
-
-  SendStreamDataToPeer(1, "foo", 12, !kFin, &last_packet);
-  EXPECT_EQ(5u, last_packet);
-  EXPECT_EQ(PACKET_6BYTE_PACKET_NUMBER,
-            QuicPacketCreatorPeer::NextPacketNumberLength(creator_));
-  EXPECT_EQ(PACKET_4BYTE_PACKET_NUMBER,
-            writer_->header().public_header.packet_number_length);
-}
-
-// TODO(ianswett): Re-enable this test by finding a good way to test different
-// packet number lengths without sending packets with giant gaps.
-TEST_P(QuicConnectionTest,
-       DISABLED_SendingDifferentSequenceNumberLengthsUnackedDelta) {
-  QuicPacketNumber last_packet;
-  SendStreamDataToPeer(1, "foo", 0, !kFin, &last_packet);
-  EXPECT_EQ(1u, last_packet);
-  EXPECT_EQ(PACKET_1BYTE_PACKET_NUMBER,
-            QuicPacketCreatorPeer::NextPacketNumberLength(creator_));
-  EXPECT_EQ(PACKET_1BYTE_PACKET_NUMBER,
-            writer_->header().public_header.packet_number_length);
-
-  QuicPacketCreatorPeer::SetPacketNumber(&peer_creator_, 100);
-
-  SendStreamDataToPeer(1, "bar", 3, !kFin, &last_packet);
-  EXPECT_EQ(PACKET_2BYTE_PACKET_NUMBER,
-            QuicPacketCreatorPeer::NextPacketNumberLength(creator_));
-  EXPECT_EQ(PACKET_1BYTE_PACKET_NUMBER,
-            writer_->header().public_header.packet_number_length);
-
-  QuicPacketCreatorPeer::SetPacketNumber(&peer_creator_, 100 * 256);
-
-  SendStreamDataToPeer(1, "foo", 6, !kFin, &last_packet);
-  EXPECT_EQ(PACKET_4BYTE_PACKET_NUMBER,
-            QuicPacketCreatorPeer::NextPacketNumberLength(creator_));
-  EXPECT_EQ(PACKET_2BYTE_PACKET_NUMBER,
-            writer_->header().public_header.packet_number_length);
-
-  QuicPacketCreatorPeer::SetPacketNumber(&peer_creator_, 100 * 256 * 256);
-
-  SendStreamDataToPeer(1, "bar", 9, !kFin, &last_packet);
-  EXPECT_EQ(PACKET_4BYTE_PACKET_NUMBER,
-            QuicPacketCreatorPeer::NextPacketNumberLength(creator_));
-  EXPECT_EQ(PACKET_4BYTE_PACKET_NUMBER,
-            writer_->header().public_header.packet_number_length);
-
-  QuicPacketCreatorPeer::SetPacketNumber(&peer_creator_, 100 * 256 * 256 * 256);
-
-  SendStreamDataToPeer(1, "foo", 12, !kFin, &last_packet);
-  EXPECT_EQ(PACKET_6BYTE_PACKET_NUMBER,
-            QuicPacketCreatorPeer::NextPacketNumberLength(creator_));
-  EXPECT_EQ(PACKET_4BYTE_PACKET_NUMBER,
-            writer_->header().public_header.packet_number_length);
-}
-
 TEST_P(QuicConnectionTest, BasicSending) {
   EXPECT_CALL(visitor_, OnSuccessfulVersionNegotiation(_));
   QuicPacketNumber last_packet;
   SendStreamDataToPeer(1, "foo", 0, !kFin, &last_packet);  // Packet 1
   EXPECT_EQ(1u, last_packet);
   SendAckPacketToPeer();  // Packet 2
 
   EXPECT_EQ(1u, least_unacked());
 
   SendAckPacketToPeer();  // Packet 3
@@ skipping 3314 matching lines @@
   // result in multiple attempts to close the connection - it will be marked as
   // disconnected after the first call.
   EXPECT_CALL(visitor_, OnConnectionClosed(_, _, _)).Times(1);
   connection_.CloseConnection(QUIC_NO_ERROR, "no reason",
                               ConnectionCloseBehavior::SILENT_CLOSE);
   connection_.CloseConnection(QUIC_NO_ERROR, "no reason",
                               ConnectionCloseBehavior::SILENT_CLOSE);
 }
 
 TEST_P(QuicConnectionTest, ServerReceivesChloOnNonCryptoStream) {
-  FLAGS_quic_detect_memory_corrpution = true;
   EXPECT_CALL(visitor_, OnSuccessfulVersionNegotiation(_));
 
   set_perspective(Perspective::IS_SERVER);
   QuicPacketCreatorPeer::SetSendVersionInPacket(creator_, false);
 
   CryptoHandshakeMessage message;
   CryptoFramer framer;
   message.set_tag(kCHLO);
   std::unique_ptr<QuicData> data(framer.ConstructHandshakeMessage(message));
   frame1_.stream_id = 10;
   frame1_.data_buffer = data->data();
   frame1_.data_length = data->length();
 
   EXPECT_CALL(visitor_, OnConnectionClosed(QUIC_MAYBE_CORRUPTED_MEMORY, _,
                                            ConnectionCloseSource::FROM_SELF));
   ProcessFramePacket(QuicFrame(&frame1_));
 }
 
 TEST_P(QuicConnectionTest, ClientReceivesRejOnNonCryptoStream) {
-  FLAGS_quic_detect_memory_corrpution = true;
   EXPECT_CALL(visitor_, OnSuccessfulVersionNegotiation(_));
 
   CryptoHandshakeMessage message;
   CryptoFramer framer;
   message.set_tag(kREJ);
   std::unique_ptr<QuicData> data(framer.ConstructHandshakeMessage(message));
   frame1_.stream_id = 10;
   frame1_.data_buffer = data->data();
   frame1_.data_length = data->length();
 
   EXPECT_CALL(visitor_, OnConnectionClosed(QUIC_MAYBE_CORRUPTED_MEMORY, _,
                                            ConnectionCloseSource::FROM_SELF));
   ProcessFramePacket(QuicFrame(&frame1_));
 }
 
 }  // namespace
 }  // namespace test
 }  // namespace net