Land Recent QUIC Changes until 2/21/2015.

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 "base/basictypes.h"
 #include "base/bind.h"
+#include "base/memory/scoped_ptr.h"
 #include "base/stl_util.h"
 #include "net/base/net_errors.h"
 #include "net/quic/congestion_control/loss_detection_interface.h"
 #include "net/quic/congestion_control/send_algorithm_interface.h"
 #include "net/quic/crypto/null_encrypter.h"
 #include "net/quic/crypto/quic_decrypter.h"
 #include "net/quic/crypto/quic_encrypter.h"
 #include "net/quic/quic_ack_notifier.h"
 #include "net/quic/quic_flags.h"
 #include "net/quic/quic_protocol.h"
@@ skipping 1553 matching lines @@
   SendAckPacketToPeer();  // Packet 7
   EXPECT_EQ(7u, least_unacked());
 
   // But if we send more data it should.
   SendStreamDataToPeer(1, "eep", 6, !kFin, &last_packet);  // Packet 8
   EXPECT_EQ(8u, last_packet);
   SendAckPacketToPeer();  // Packet 9
   EXPECT_EQ(7u, least_unacked());
 }
 
-// If FLAGS_quic_record_send_time_before_write is disabled, QuicConnection
-// should record the packet sen-tdime after the packet is sent.
-TEST_P(QuicConnectionTest, RecordSentTimeAfterPacketSent) {
-  ValueRestore<bool> old_flag(&FLAGS_quic_record_send_time_before_write, false);
+// QuicConnection should record the the packet sent-time prior to sending the
+// packet.
+TEST_P(QuicConnectionTest, RecordSentTimeBeforePacketSent) {
   // We're using a MockClock for the tests, so we have complete control over the
   // time.
   // Our recorded timestamp for the last packet sent time will be passed in to
-  // the send_algorithm.  Make sure that it is set to the correct value.
-  QuicTime actual_recorded_send_time = QuicTime::Zero();
-  EXPECT_CALL(*send_algorithm_, OnPacketSent(_, _, _, _, _))
-      .WillOnce(DoAll(SaveArg<0>(&actual_recorded_send_time), Return(true)));
-
-  // First send without any pause and check the result.
-  QuicTime expected_recorded_send_time = clock_.Now();
-  connection_.SendStreamDataWithString(1, "foo", 0, !kFin, nullptr);
-  EXPECT_EQ(expected_recorded_send_time, actual_recorded_send_time)
-      << "Expected time = " << expected_recorded_send_time.ToDebuggingValue()
-      << ".  Actual time = " << actual_recorded_send_time.ToDebuggingValue();
-
-  // Now pause during the write, and check the results.
-  actual_recorded_send_time = QuicTime::Zero();
-  const QuicTime::Delta kWritePauseTimeDelta =
-      QuicTime::Delta::FromMilliseconds(5000);
-  SetWritePauseTimeDelta(kWritePauseTimeDelta);
-  expected_recorded_send_time = clock_.Now().Add(kWritePauseTimeDelta);
-
-  EXPECT_CALL(*send_algorithm_, OnPacketSent(_, _, _, _, _))
-      .WillOnce(DoAll(SaveArg<0>(&actual_recorded_send_time), Return(true)));
-  connection_.SendStreamDataWithString(2, "baz", 0, !kFin, nullptr);
-  EXPECT_EQ(expected_recorded_send_time, actual_recorded_send_time)
-      << "Expected time = " << expected_recorded_send_time.ToDebuggingValue()
-      << ".  Actual time = " << actual_recorded_send_time.ToDebuggingValue();
-}
-
-// If FLAGS_quic_record_send_time_before_write is enabled, QuicConnection should
-// record the the packet sent-time prior to sending the packet.
-TEST_P(QuicConnectionTest, RecordSentTimeBeforePacketSent) {
-  ValueRestore<bool> old_flag(&FLAGS_quic_record_send_time_before_write, true);
-  // We're using a MockClock for the tests, so we have complete control over the
-  // time.
-  // Our recorded timestamp for the last packet sent time will be passed in to
   // the send_algorithm.  Make sure that it is set to the correct value.
   QuicTime actual_recorded_send_time = QuicTime::Zero();
   EXPECT_CALL(*send_algorithm_, OnPacketSent(_, _, _, _, _))
       .WillOnce(DoAll(SaveArg<0>(&actual_recorded_send_time), Return(true)));
 
   // First send without any pause and check the result.
   QuicTime expected_recorded_send_time = clock_.Now();
   connection_.SendStreamDataWithString(1, "foo", 0, !kFin, nullptr);
   EXPECT_EQ(expected_recorded_send_time, actual_recorded_send_time)
       << "Expected time = " << expected_recorded_send_time.ToDebuggingValue()
@@ skipping 890 matching lines @@
   // Don't send missing packet 1.
   ProcessFecPacket(2, 1, true, !kEntropyFlag, nullptr);
   // Entropy flag should be false, so entropy should be 0.
   EXPECT_EQ(0u, QuicConnectionPeer::ReceivedEntropyHash(&connection_, 2));
 }
 
 TEST_P(QuicConnectionTest, ReviveMissingPacketWithVaryingSeqNumLengths) {
   EXPECT_CALL(visitor_, OnSuccessfulVersionNegotiation(_));
 
   // Set up a debug visitor to the connection.
-  FecQuicConnectionDebugVisitor* fec_visitor =
-      new FecQuicConnectionDebugVisitor();
-  connection_.set_debug_visitor(fec_visitor);
+  scoped_ptr<FecQuicConnectionDebugVisitor> fec_visitor(
+      new FecQuicConnectionDebugVisitor());
+  connection_.set_debug_visitor(fec_visitor.get());
 
   QuicPacketSequenceNumber fec_packet = 0;
   QuicSequenceNumberLength lengths[] = {PACKET_6BYTE_SEQUENCE_NUMBER,
                                         PACKET_4BYTE_SEQUENCE_NUMBER,
                                         PACKET_2BYTE_SEQUENCE_NUMBER,
                                         PACKET_1BYTE_SEQUENCE_NUMBER};
   // For each sequence number length size, revive a packet and check sequence
   // number length in the revived packet.
   for (size_t i = 0; i < arraysize(lengths); ++i) {
     // Set sequence_number_length_ (for data and FEC packets).
     sequence_number_length_ = lengths[i];
     fec_packet += 2;
     // Don't send missing packet, but send fec packet right after it.
     ProcessFecPacket(fec_packet, fec_packet - 1, true, !kEntropyFlag, nullptr);
     // Sequence number length in the revived header should be the same as
     // in the original data/fec packet headers.
     EXPECT_EQ(sequence_number_length_, fec_visitor->revived_header().
                                        public_header.sequence_number_length);
   }
 }
 
 TEST_P(QuicConnectionTest, ReviveMissingPacketWithVaryingConnectionIdLengths) {
   EXPECT_CALL(visitor_, OnSuccessfulVersionNegotiation(_));
 
   // Set up a debug visitor to the connection.
-  FecQuicConnectionDebugVisitor* fec_visitor =
-      new FecQuicConnectionDebugVisitor();
-  connection_.set_debug_visitor(fec_visitor);
+  scoped_ptr<FecQuicConnectionDebugVisitor> fec_visitor(
+      new FecQuicConnectionDebugVisitor());
+  connection_.set_debug_visitor(fec_visitor.get());
 
   QuicPacketSequenceNumber fec_packet = 0;
   QuicConnectionIdLength lengths[] = {PACKET_8BYTE_CONNECTION_ID,
                                       PACKET_4BYTE_CONNECTION_ID,
                                       PACKET_1BYTE_CONNECTION_ID,
                                       PACKET_0BYTE_CONNECTION_ID};
   // For each connection id length size, revive a packet and check connection
   // id length in the revived packet.
   for (size_t i = 0; i < arraysize(lengths); ++i) {
     // Set connection id length (for data and FEC packets).
@@ skipping 1787 matching lines @@
   MOCK_METHOD1(OnVersionNegotiationPacket,
                void(const QuicVersionNegotiationPacket&));
 
   MOCK_METHOD2(OnRevivedPacket,
                void(const QuicPacketHeader&, StringPiece payload));
 };
 
 TEST_P(QuicConnectionTest, OnPacketHeaderDebugVisitor) {
   QuicPacketHeader header;
 
-  MockQuicConnectionDebugVisitor* debug_visitor =
-      new MockQuicConnectionDebugVisitor();
-  connection_.set_debug_visitor(debug_visitor);
+  scoped_ptr<MockQuicConnectionDebugVisitor> debug_visitor(
+      new MockQuicConnectionDebugVisitor());
+  connection_.set_debug_visitor(debug_visitor.get());
   EXPECT_CALL(*debug_visitor, OnPacketHeader(Ref(header))).Times(1);
   connection_.OnPacketHeader(header);
 }
 
 TEST_P(QuicConnectionTest, Pacing) {
   TestConnection server(connection_id_, IPEndPoint(), helper_.get(),
                         factory_, /* is_server= */ true, version());
   TestConnection client(connection_id_, IPEndPoint(), helper_.get(),
                         factory_, /* is_server= */ false, version());
   EXPECT_FALSE(client.sent_packet_manager().using_pacing());
@@ skipping 29 matching lines @@
   // Regression test for b/18594622
   scoped_refptr<MockAckNotifierDelegate> delegate(new MockAckNotifierDelegate);
   EXPECT_DFATAL(
       connection_.SendStreamDataWithString(3, "", 0, !kFin, delegate.get()),
       "Attempt to send empty stream frame");
 }
 
 }  // namespace
 }  // namespace test
 }  // namespace net