Landing Recent QUIC changes until 01/28/2016 18:41 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 <ostream>
 
 #include "base/bind.h"
 #include "base/macros.h"
@@ skipping 440 matching lines @@
   }
 
   void SendPacket(EncryptionLevel level,
                   QuicPathId path_id,
                   QuicPacketNumber packet_number,
                   QuicPacket* packet,
                   QuicPacketEntropyHash entropy_hash,
                   HasRetransmittableData retransmittable,
                   bool has_ack,
                   bool has_pending_frames) {
-    QuicFrames* retransmittable_frames =
-        retransmittable == HAS_RETRANSMITTABLE_DATA ? new QuicFrames()
-                                                    : nullptr;
     char buffer[kMaxPacketSize];
     size_t encrypted_length =
         QuicConnectionPeer::GetFramer(this)->EncryptPayload(
             ENCRYPTION_NONE, path_id, packet_number, *packet, buffer,
             kMaxPacketSize);
     delete packet;
     SerializedPacket serialized_packet(
-        kDefaultPathId, packet_number, PACKET_6BYTE_PACKET_NUMBER, buffer,
-        encrypted_length, false, entropy_hash, retransmittable_frames, false,
-        NOT_HANDSHAKE, has_ack, has_pending_frames, ENCRYPTION_NONE);
+        kDefaultPathId, packet_number, PACKET_6BYTE_PACKET_NUMBER,
+        new QuicEncryptedPacket(buffer, encrypted_length, false), entropy_hash,
+        has_ack, has_pending_frames);
+    if (retransmittable == HAS_RETRANSMITTABLE_DATA) {
+      serialized_packet.retransmittable_frames.push_back(
+          QuicFrame(new QuicStreamFrame()));
+    }
     OnSerializedPacket(&serialized_packet);
   }
 
   QuicConsumedData SendStreamDataWithString(
       QuicStreamId id,
       StringPiece data,
       QuicStreamOffset offset,
       bool fin,
       QuicAckListenerInterface* listener) {
     return SendStreamDataWithStringHelper(id, data, offset, fin,
@@ skipping 238 matching lines @@
     EXPECT_CALL(visitor_, WillingAndAbleToWrite()).Times(AnyNumber());
     EXPECT_CALL(visitor_, HasPendingHandshake()).Times(AnyNumber());
     EXPECT_CALL(visitor_, OnCanWrite()).Times(AnyNumber());
     EXPECT_CALL(visitor_, PostProcessAfterData()).Times(AnyNumber());
     EXPECT_CALL(visitor_, HasOpenDynamicStreams())
         .WillRepeatedly(Return(false));
     EXPECT_CALL(visitor_, OnCongestionWindowChange(_)).Times(AnyNumber());
 
     EXPECT_CALL(*loss_algorithm_, GetLossTimeout())
         .WillRepeatedly(Return(QuicTime::Zero()));
-    if (FLAGS_quic_general_loss_algorithm) {
-      EXPECT_CALL(*loss_algorithm_, DetectLosses(_, _, _, _))
-          .Times(AnyNumber());
-    } else {
-      EXPECT_CALL(*loss_algorithm_, DetectLostPackets(_, _, _, _))
-          .WillRepeatedly(Return(PacketNumberSet()));
-    }
+    EXPECT_CALL(*loss_algorithm_, DetectLosses(_, _, _, _)).Times(AnyNumber());
     // TODO(ianswett): Fix QuicConnectionTests so they don't attempt to write
     // non-crypto stream data at ENCRYPTION_NONE.
     FLAGS_quic_never_write_unencrypted_data = false;
     FLAGS_quic_no_unencrypted_fec = false;
   }
 
   QuicVersion version() { return GetParam().version; }
 
   QuicAckFrame* outgoing_ack() {
     QuicConnectionPeer::PopulateAckFrame(&connection_, &ack_);
@@ skipping 20 matching lines @@
   }
 
   QuicPacketEntropyHash ProcessFramePacket(QuicFrame frame) {
     QuicFrames frames;
     frames.push_back(QuicFrame(frame));
     QuicPacketCreatorPeer::SetSendVersionInPacket(
         &peer_creator_, connection_.perspective() == Perspective::IS_SERVER);
 
     char buffer[kMaxPacketSize];
     SerializedPacket serialized_packet =
-        peer_creator_.SerializeAllFrames(frames, buffer, kMaxPacketSize);
+        QuicPacketCreatorPeer::SerializeAllFrames(&peer_creator_, frames,
+                                                  buffer, kMaxPacketSize);
     scoped_ptr<QuicEncryptedPacket> encrypted(serialized_packet.packet);
     connection_.ProcessUdpPacket(kSelfAddress, kPeerAddress, *encrypted);
     return serialized_packet.entropy_hash;
   }
 
   QuicPacketEntropyHash ProcessFramePacketAtLevel(QuicPathId path_id,
                                                   QuicPacketNumber number,
                                                   QuicFrame frame,
                                                   EncryptionLevel level) {
     QuicPacketHeader header;
@@ skipping 577 matching lines @@
 
   QuicAckFrame frame = InitAckFrame(num_packets);
   PacketNumberSet lost_packets;
   // Create an ack with 256 nacks, none adjacent to one another.
   for (QuicPacketNumber i = 1; i <= 256; ++i) {
     NackPacket(i * 2, &frame);
     if (i < 256) {  // Last packet is nacked, but not lost.
       lost_packets.insert(i * 2);
     }
   }
-  if (FLAGS_quic_general_loss_algorithm) {
-    EXPECT_CALL(*loss_algorithm_, DetectLosses(_, _, _, _));
-  } else {
-    EXPECT_CALL(*loss_algorithm_, DetectLostPackets(_, _, _, _))
-        .WillOnce(Return(lost_packets));
-  }
+  EXPECT_CALL(*loss_algorithm_, DetectLosses(_, _, _, _));
   EXPECT_CALL(entropy_calculator_, EntropyHash(511))
       .WillOnce(Return(static_cast<QuicPacketEntropyHash>(0)));
   EXPECT_CALL(*send_algorithm_, OnCongestionEvent(true, _, _, _));
   ProcessAckPacket(&frame);
 
   // A truncated ack will not have the true largest observed.
   EXPECT_GT(num_packets, manager_->largest_observed());
 
   AckPacket(192, &frame);
 
   // Removing one missing packet allows us to ack 192 and one more range, but
   // 192 has already been declared lost, so it doesn't register as an ack.
-  if (FLAGS_quic_general_loss_algorithm) {
-    EXPECT_CALL(*loss_algorithm_, DetectLosses(_, _, _, _));
-  } else {
-    EXPECT_CALL(*loss_algorithm_, DetectLostPackets(_, _, _, _))
-        .WillOnce(Return(PacketNumberSet()));
-  }
+  EXPECT_CALL(*loss_algorithm_, DetectLosses(_, _, _, _));
   EXPECT_CALL(*send_algorithm_, OnCongestionEvent(true, _, _, _));
   ProcessAckPacket(&frame);
   EXPECT_EQ(num_packets, manager_->largest_observed());
 }
 
 TEST_P(QuicConnectionTest, AckReceiptCausesAckSendBadEntropy) {
   EXPECT_CALL(visitor_, OnSuccessfulVersionNegotiation(_));
 
   ProcessPacket(kDefaultPathId, 1);
   // Delay sending, then queue up an ack.
@@ skipping 56 matching lines @@
 
   QuicPacketNumber original;
   QuicByteCount packet_size;
   EXPECT_CALL(*send_algorithm_, OnPacketSent(_, _, _, _, _))
       .WillOnce(
           DoAll(SaveArg<2>(&original), SaveArg<3>(&packet_size), Return(true)));
   connection_.SendStreamDataWithString(3, "foo", 0, !kFin, nullptr);
   QuicAckFrame frame = InitAckFrame(original);
   NackPacket(original, &frame);
   // First nack triggers early retransmit.
-  if (FLAGS_quic_general_loss_algorithm) {
-    SendAlgorithmInterface::CongestionVector lost_packets;
-    lost_packets.push_back(std::make_pair(1, kMaxPacketSize));
-    EXPECT_CALL(*loss_algorithm_, DetectLosses(_, _, _, _))
-        .WillOnce(SetArgPointee<3>(lost_packets));
-  } else {
-    PacketNumberSet lost_packets;
-    lost_packets.insert(1);
-    EXPECT_CALL(*loss_algorithm_, DetectLostPackets(_, _, _, _))
-        .WillOnce(Return(lost_packets));
-  }
+  SendAlgorithmInterface::CongestionVector lost_packets;
+  lost_packets.push_back(std::make_pair(1, kMaxPacketSize));
+  EXPECT_CALL(*loss_algorithm_, DetectLosses(_, _, _, _))
+      .WillOnce(SetArgPointee<3>(lost_packets));
   EXPECT_CALL(*send_algorithm_, OnCongestionEvent(true, _, _, _));
   QuicPacketNumber retransmission;
   EXPECT_CALL(*send_algorithm_,
               OnPacketSent(_, _, _, packet_size - kQuicVersionSize, _))
       .WillOnce(DoAll(SaveArg<2>(&retransmission), Return(true)));
 
   ProcessAckPacket(&frame);
 
   QuicAckFrame frame2 = InitAckFrame(retransmission);
   NackPacket(original, &frame2);
   EXPECT_CALL(*send_algorithm_, OnCongestionEvent(true, _, _, _));
-  if (FLAGS_quic_general_loss_algorithm) {
-    EXPECT_CALL(*loss_algorithm_, DetectLosses(_, _, _, _));
-  } else {
-    EXPECT_CALL(*loss_algorithm_, DetectLostPackets(_, _, _, _))
-        .WillOnce(Return(PacketNumberSet()));
-  }
+  EXPECT_CALL(*loss_algorithm_, DetectLosses(_, _, _, _));
   ProcessAckPacket(&frame2);
 
   // Now if the peer sends an ack which still reports the retransmitted packet
   // as missing, that will bundle an ack with data after two acks in a row
   // indicate the high water mark needs to be raised.
   EXPECT_CALL(*send_algorithm_,
               OnPacketSent(_, _, _, _, HAS_RETRANSMITTABLE_DATA));
   connection_.SendStreamDataWithString(3, "foo", 3, !kFin, nullptr);
   // No ack sent.
   EXPECT_EQ(1u, writer_->frame_count());
   EXPECT_EQ(1u, writer_->stream_frames().size());
 
   // No more packet loss for the rest of the test.
-  if (FLAGS_quic_general_loss_algorithm) {
-    EXPECT_CALL(*loss_algorithm_, DetectLosses(_, _, _, _)).Times(AnyNumber());
-  } else {
-    EXPECT_CALL(*loss_algorithm_, DetectLostPackets(_, _, _, _))
-        .WillRepeatedly(Return(PacketNumberSet()));
-  }
+  EXPECT_CALL(*loss_algorithm_, DetectLosses(_, _, _, _)).Times(AnyNumber());
   ProcessAckPacket(&frame2);
   EXPECT_CALL(*send_algorithm_,
               OnPacketSent(_, _, _, _, HAS_RETRANSMITTABLE_DATA));
   connection_.SendStreamDataWithString(3, "foo", 3, !kFin, nullptr);
   // Ack bundled.
   EXPECT_EQ(3u, writer_->frame_count());
   EXPECT_EQ(1u, writer_->stream_frames().size());
   EXPECT_FALSE(writer_->ack_frames().empty());
 
   // But an ack with no missing packets will not send an ack.
@@ skipping 456 matching lines @@
   // stream frame size, which are absent in the retransmission.
   size_t retransmitted_packet = protected_packet - 3;
   EXPECT_EQ(protected_packet + retransmitted_packet,
             QuicSentPacketManagerPeer::GetBytesInFlight(manager_));
   EXPECT_FALSE(connection_.GetFecAlarm()->IsSet());
 
   // Receive ack for the retransmission. No data should be outstanding.
   QuicAckFrame ack = InitAckFrame(3);
   NackPacket(1, &ack);
   NackPacket(2, &ack);
-  if (FLAGS_quic_general_loss_algorithm) {
-    SendAlgorithmInterface::CongestionVector lost_packets;
-    lost_packets.push_back(std::make_pair(1, kMaxPacketSize));
-    EXPECT_CALL(*loss_algorithm_, DetectLosses(_, _, _, _))
-        .WillOnce(SetArgPointee<3>(lost_packets));
-  } else {
-    PacketNumberSet lost_packets;
-    lost_packets.insert(1);
-    EXPECT_CALL(*loss_algorithm_, DetectLostPackets(_, _, _, _))
-        .WillOnce(Return(lost_packets));
-  }
+  SendAlgorithmInterface::CongestionVector lost_packets;
+  lost_packets.push_back(std::make_pair(1, kMaxPacketSize));
+  EXPECT_CALL(*loss_algorithm_, DetectLosses(_, _, _, _))
+      .WillOnce(SetArgPointee<3>(lost_packets));
   EXPECT_CALL(*send_algorithm_, OnCongestionEvent(true, _, _, _));
   ProcessAckPacket(&ack);
 
   // Ensure the alarm is not set since all packets have been acked or abandoned.
   EXPECT_FALSE(connection_.GetRetransmissionAlarm()->IsSet());
   EXPECT_EQ(0u, QuicSentPacketManagerPeer::GetBytesInFlight(manager_));
 }
 
 TEST_P(QuicConnectionTest, RemoveFECFromInflightOnLossRetransmission) {
   EXPECT_TRUE(QuicPacketCreatorPeer::IsFecEnabled(creator_));
@@ skipping 35 matching lines @@
   EXPECT_EQ(protected_packet + fec_packet + 4 * unprotected_packet,
             QuicSentPacketManagerPeer::GetBytesInFlight(manager_));
   EXPECT_FALSE(connection_.GetFecAlarm()->IsSet());
 
   // Ack data packets, and NACK FEC packet and one data packet. Triggers
   // NACK-based loss detection of both packets, but only data packet is
   // retransmitted and considered outstanding.
   QuicAckFrame ack = InitAckFrame(6);
   NackPacket(2, &ack);
   NackPacket(3, &ack);
-  if (FLAGS_quic_general_loss_algorithm) {
-    SendAlgorithmInterface::CongestionVector lost_packets;
-    lost_packets.push_back(std::make_pair(2, kMaxPacketSize));
-    lost_packets.push_back(std::make_pair(3, kMaxPacketSize));
-    EXPECT_CALL(*loss_algorithm_, DetectLosses(_, _, _, _))
-        .WillOnce(SetArgPointee<3>(lost_packets));
-  } else {
-    PacketNumberSet lost_packets;
-    lost_packets.insert(2);
-    lost_packets.insert(3);
-    EXPECT_CALL(*loss_algorithm_, DetectLostPackets(_, _, _, _))
-        .WillOnce(Return(lost_packets));
-  }
+  SendAlgorithmInterface::CongestionVector lost_packets;
+  lost_packets.push_back(std::make_pair(2, kMaxPacketSize));
+  lost_packets.push_back(std::make_pair(3, kMaxPacketSize));
+  EXPECT_CALL(*loss_algorithm_, DetectLosses(_, _, _, _))
+      .WillOnce(SetArgPointee<3>(lost_packets));
   EXPECT_CALL(*send_algorithm_, OnCongestionEvent(true, _, _, _));
   EXPECT_CALL(*send_algorithm_,
               OnPacketSent(_, _, _, _, HAS_RETRANSMITTABLE_DATA))
       .Times(1);
   EXPECT_CALL(visitor_, OnSuccessfulVersionNegotiation(_));
   ProcessAckPacket(&ack);
   // On receiving this ack from the server, the client will no longer send
   // version number in subsequent packets, including in this retransmission.
   size_t unprotected_packet_no_version = unprotected_packet - 4;
   EXPECT_EQ(unprotected_packet_no_version,
             QuicSentPacketManagerPeer::GetBytesInFlight(manager_));
 
   // Receive ack for the retransmission. No data should be outstanding.
   QuicAckFrame ack2 = InitAckFrame(7);
   NackPacket(2, &ack2);
   NackPacket(3, &ack2);
-  if (FLAGS_quic_general_loss_algorithm) {
-    EXPECT_CALL(*loss_algorithm_, DetectLosses(_, _, _, _));
-  } else {
-    EXPECT_CALL(*loss_algorithm_, DetectLostPackets(_, _, _, _))
-        .WillOnce(Return(PacketNumberSet()));
-  }
+  EXPECT_CALL(*loss_algorithm_, DetectLosses(_, _, _, _));
   EXPECT_CALL(*send_algorithm_, OnCongestionEvent(true, _, _, _));
   ProcessAckPacket(&ack2);
   EXPECT_EQ(0u, QuicSentPacketManagerPeer::GetBytesInFlight(manager_));
 }
 
 TEST_P(QuicConnectionTest, FECRemainsInflightOnTLPOfEarlierData) {
   // This test checks if TLP is sent correctly when a data and an FEC packet
   // are outstanding. TLP should be sent for the data packet when the
   // retransmission alarm fires.
   // Turn on TLP for this test.
@@ skipping 370 matching lines @@
   EXPECT_CALL(visitor_, OnSuccessfulVersionNegotiation(_));
 
   // Don't lose a packet on an ack, and nothing is retransmitted.
   EXPECT_CALL(*send_algorithm_, OnCongestionEvent(true, _, _, _));
   QuicAckFrame ack_one = InitAckFrame(1);
   ProcessAckPacket(&ack_one);
 
   // Lose a packet and ensure it triggers retransmission.
   QuicAckFrame nack_two = InitAckFrame(3);
   NackPacket(2, &nack_two);
-  if (FLAGS_quic_general_loss_algorithm) {
-    SendAlgorithmInterface::CongestionVector lost_packets;
-    lost_packets.push_back(std::make_pair(2, kMaxPacketSize));
-    EXPECT_CALL(*loss_algorithm_, DetectLosses(_, _, _, _))
-        .WillOnce(SetArgPointee<3>(lost_packets));
-  } else {
-    PacketNumberSet lost_packets;
-    lost_packets.insert(2);
-    EXPECT_CALL(*loss_algorithm_, DetectLostPackets(_, _, _, _))
-        .WillOnce(Return(lost_packets));
-  }
+  SendAlgorithmInterface::CongestionVector lost_packets;
+  lost_packets.push_back(std::make_pair(2, kMaxPacketSize));
+  EXPECT_CALL(*loss_algorithm_, DetectLosses(_, _, _, _))
+      .WillOnce(SetArgPointee<3>(lost_packets));
   EXPECT_CALL(*send_algorithm_, OnCongestionEvent(true, _, _, _));
   EXPECT_CALL(*send_algorithm_,
               OnPacketSent(_, _, _, second_packet_size - kQuicVersionSize, _))
       .Times(1);
   ProcessAckPacket(&nack_two);
 }
 
 TEST_P(QuicConnectionTest, DoNotSendQueuedPacketForResetStream) {
   // Block the connection to queue the packet.
   BlockOnNextWrite();
@@ skipping 43 matching lines @@
   SendStreamDataToPeer(stream_id, "foos", 3, !kFin, &last_packet);
   SendStreamDataToPeer(stream_id, "fooos", 7, !kFin, &last_packet);
 
   EXPECT_CALL(*send_algorithm_, OnPacketSent(_, _, _, _, _)).Times(1);
   connection_.SendRstStream(stream_id, QUIC_ERROR_PROCESSING_STREAM, 14);
 
   // Lose a packet and ensure it does not trigger retransmission.
   QuicAckFrame nack_two = InitAckFrame(last_packet);
   NackPacket(last_packet - 1, &nack_two);
   EXPECT_CALL(visitor_, OnSuccessfulVersionNegotiation(_));
-  if (FLAGS_quic_general_loss_algorithm) {
-    EXPECT_CALL(*loss_algorithm_, DetectLosses(_, _, _, _));
-  } else {
-    PacketNumberSet lost_packets;
-    lost_packets.insert(last_packet - 1);
-    EXPECT_CALL(*loss_algorithm_, DetectLostPackets(_, _, _, _))
-        .WillOnce(Return(lost_packets));
-  }
+  EXPECT_CALL(*loss_algorithm_, DetectLosses(_, _, _, _));
   EXPECT_CALL(*send_algorithm_, OnCongestionEvent(true, _, _, _));
   EXPECT_CALL(*send_algorithm_, OnPacketSent(_, _, _, _, _)).Times(0);
   ProcessAckPacket(&nack_two);
 }
 
 TEST_P(QuicConnectionTest, RetransmitForQuicRstStreamNoErrorOnNack) {
   QuicStreamId stream_id = 2;
   QuicPacketNumber last_packet;
   SendStreamDataToPeer(stream_id, "foo", 0, !kFin, &last_packet);
   SendStreamDataToPeer(stream_id, "foos", 3, !kFin, &last_packet);
   SendStreamDataToPeer(stream_id, "fooos", 7, !kFin, &last_packet);
 
   EXPECT_CALL(*send_algorithm_, OnPacketSent(_, _, _, _, _)).Times(1);
   connection_.SendRstStream(stream_id, QUIC_STREAM_NO_ERROR, 14);
 
   // Lose a packet, ensure it triggers retransmission on QUIC_VERSION_29
   // or later versions.
   QuicAckFrame nack_two = InitAckFrame(last_packet);
   NackPacket(last_packet - 1, &nack_two);
   EXPECT_CALL(visitor_, OnSuccessfulVersionNegotiation(_));
-  if (FLAGS_quic_general_loss_algorithm) {
-    SendAlgorithmInterface::CongestionVector lost_packets;
-    lost_packets.push_back(std::make_pair(last_packet - 1, kMaxPacketSize));
-    EXPECT_CALL(*loss_algorithm_, DetectLosses(_, _, _, _))
-        .WillOnce(SetArgPointee<3>(lost_packets));
-  } else {
-    PacketNumberSet lost_packets;
-    lost_packets.insert(last_packet - 1);
-    EXPECT_CALL(*loss_algorithm_, DetectLostPackets(_, _, _, _))
-        .WillOnce(Return(lost_packets));
-  }
+  SendAlgorithmInterface::CongestionVector lost_packets;
+  lost_packets.push_back(std::make_pair(last_packet - 1, kMaxPacketSize));
+  EXPECT_CALL(*loss_algorithm_, DetectLosses(_, _, _, _))
+      .WillOnce(SetArgPointee<3>(lost_packets));
   EXPECT_CALL(*send_algorithm_, OnCongestionEvent(true, _, _, _));
   if (version() > QUIC_VERSION_28) {
     EXPECT_CALL(*send_algorithm_, OnPacketSent(_, _, _, _, _))
         .Times(AtLeast(1));
   } else {
     EXPECT_CALL(*send_algorithm_, OnPacketSent(_, _, _, _, _)).Times(0);
   }
   ProcessAckPacket(&nack_two);
 }
 
@@ skipping 44 matching lines @@
   SendStreamDataToPeer(stream_id, "foos", 3, !kFin, &last_packet);
   BlockOnNextWrite();
   connection_.SendStreamDataWithString(stream_id, "fooos", 7, !kFin, nullptr);
 
   // Lose a packet which will trigger a pending retransmission.
   QuicAckFrame ack = InitAckFrame(last_packet);
   NackPacket(last_packet - 1, &ack);
   PacketNumberSet lost_packets;
   lost_packets.insert(last_packet - 1);
   EXPECT_CALL(visitor_, OnSuccessfulVersionNegotiation(_));
-  if (FLAGS_quic_general_loss_algorithm) {
-    EXPECT_CALL(*loss_algorithm_, DetectLosses(_, _, _, _));
-  } else {
-    EXPECT_CALL(*loss_algorithm_, DetectLostPackets(_, _, _, _))
-        .WillOnce(Return(lost_packets));
-  }
+  EXPECT_CALL(*loss_algorithm_, DetectLosses(_, _, _, _));
   EXPECT_CALL(*send_algorithm_, OnCongestionEvent(true, _, _, _));
   EXPECT_CALL(*send_algorithm_, OnPacketSent(_, _, _, _, _)).Times(0);
   ProcessAckPacket(&ack);
 
   connection_.SendRstStream(stream_id, QUIC_ERROR_PROCESSING_STREAM, 14);
 
   // Unblock the connection and verify that the RST_STREAM is sent but not the
   // second data packet nor a retransmit.
   EXPECT_CALL(*send_algorithm_, OnPacketSent(_, _, _, _, _)).Times(1);
   writer_->SetWritable();
   connection_.OnCanWrite();
   EXPECT_EQ(1u, writer_->frame_count());
   EXPECT_EQ(1u, writer_->rst_stream_frames().size());
   EXPECT_EQ(stream_id, writer_->rst_stream_frames().front().stream_id);
 }
 
 TEST_P(QuicConnectionTest, SendPendingRetransmissionForQuicRstStreamNoError) {
   QuicStreamId stream_id = 2;
   QuicPacketNumber last_packet;
   SendStreamDataToPeer(stream_id, "foo", 0, !kFin, &last_packet);
   SendStreamDataToPeer(stream_id, "foos", 3, !kFin, &last_packet);
   BlockOnNextWrite();
   connection_.SendStreamDataWithString(stream_id, "fooos", 7, !kFin, nullptr);
 
   // Lose a packet which will trigger a pending retransmission.
   QuicAckFrame ack = InitAckFrame(last_packet);
   NackPacket(last_packet - 1, &ack);
   EXPECT_CALL(visitor_, OnSuccessfulVersionNegotiation(_));
-  if (FLAGS_quic_general_loss_algorithm) {
-    SendAlgorithmInterface::CongestionVector lost_packets;
-    lost_packets.push_back(std::make_pair(last_packet - 1, kMaxPacketSize));
-    EXPECT_CALL(*loss_algorithm_, DetectLosses(_, _, _, _))
-        .WillOnce(SetArgPointee<3>(lost_packets));
-  } else {
-    PacketNumberSet lost_packets;
-    lost_packets.insert(last_packet - 1);
-    EXPECT_CALL(*loss_algorithm_, DetectLostPackets(_, _, _, _))
-        .WillOnce(Return(lost_packets));
-  }
+  SendAlgorithmInterface::CongestionVector lost_packets;
+  lost_packets.push_back(std::make_pair(last_packet - 1, kMaxPacketSize));
+  EXPECT_CALL(*loss_algorithm_, DetectLosses(_, _, _, _))
+      .WillOnce(SetArgPointee<3>(lost_packets));
   EXPECT_CALL(*send_algorithm_, OnCongestionEvent(true, _, _, _));
   EXPECT_CALL(*send_algorithm_, OnPacketSent(_, _, _, _, _)).Times(0);
   ProcessAckPacket(&ack);
 
   connection_.SendRstStream(stream_id, QUIC_STREAM_NO_ERROR, 14);
 
   // Unblock the connection and verify that the RST_STREAM is sent and the
   // second data packet or a retransmit is only sent on QUIC_VERSION_29 or
   // later versions.
   if (version() > QUIC_VERSION_28) {
@@ skipping 21 matching lines @@
 
   EXPECT_CALL(visitor_, OnSuccessfulVersionNegotiation(_));
 
   // Instigate a loss with an ack.
   QuicAckFrame nack_two = InitAckFrame(3);
   NackPacket(2, &nack_two);
   // The first nack should trigger a fast retransmission, but we'll be
   // write blocked, so the packet will be queued.
   BlockOnNextWrite();
 
-  if (FLAGS_quic_general_loss_algorithm) {
-    SendAlgorithmInterface::CongestionVector lost_packets;
-    lost_packets.push_back(std::make_pair(2, kMaxPacketSize));
-    EXPECT_CALL(*loss_algorithm_, DetectLosses(_, _, _, _))
-        .WillOnce(SetArgPointee<3>(lost_packets));
-  } else {
-    PacketNumberSet lost_packets;
-    lost_packets.insert(2);
-    EXPECT_CALL(*loss_algorithm_, DetectLostPackets(_, _, _, _))
-        .WillOnce(Return(lost_packets));
-  }
+  SendAlgorithmInterface::CongestionVector lost_packets;
+  lost_packets.push_back(std::make_pair(2, kMaxPacketSize));
+  EXPECT_CALL(*loss_algorithm_, DetectLosses(_, _, _, _))
+      .WillOnce(SetArgPointee<3>(lost_packets));
   EXPECT_CALL(*send_algorithm_, OnCongestionEvent(true, _, _, _));
   ProcessAckPacket(&nack_two);
   EXPECT_EQ(1u, connection_.NumQueuedPackets());
 
   // Now, ack the previous transmission.
-  if (FLAGS_quic_general_loss_algorithm) {
-    EXPECT_CALL(*loss_algorithm_, DetectLosses(_, _, _, _));
-  } else {
-    EXPECT_CALL(*loss_algorithm_, DetectLostPackets(_, _, _, _))
-        .WillOnce(Return(PacketNumberSet()));
-  }
+  EXPECT_CALL(*loss_algorithm_, DetectLosses(_, _, _, _));
   QuicAckFrame ack_all = InitAckFrame(3);
   ProcessAckPacket(&ack_all);
 
   // Unblock the socket and attempt to send the queued packets.  However,
   // since the previous transmission has been acked, we will not
   // send the retransmission.
   EXPECT_CALL(*send_algorithm_, OnPacketSent(_, _, _, _, _)).Times(0);
 
   writer_->SetWritable();
   connection_.OnCanWrite();
 
   EXPECT_EQ(0u, connection_.NumQueuedPackets());
 }
 
 TEST_P(QuicConnectionTest, RetransmitNackedLargestObserved) {
   EXPECT_CALL(visitor_, OnSuccessfulVersionNegotiation(_));
   QuicPacketNumber largest_observed;
   QuicByteCount packet_size;
   EXPECT_CALL(*send_algorithm_, OnPacketSent(_, _, _, _, _))
       .WillOnce(DoAll(SaveArg<2>(&largest_observed), SaveArg<3>(&packet_size),
                       Return(true)));
   connection_.SendStreamDataWithString(3, "foo", 0, !kFin, nullptr);
 
   QuicAckFrame frame = InitAckFrame(1);
   NackPacket(largest_observed, &frame);
   // The first nack should retransmit the largest observed packet.
-  if (FLAGS_quic_general_loss_algorithm) {
-    SendAlgorithmInterface::CongestionVector lost_packets;
-    lost_packets.push_back(std::make_pair(1, kMaxPacketSize));
-    EXPECT_CALL(*loss_algorithm_, DetectLosses(_, _, _, _))
-        .WillOnce(SetArgPointee<3>(lost_packets));
-  } else {
-    PacketNumberSet lost_packets;
-    lost_packets.insert(1);
-    EXPECT_CALL(*loss_algorithm_, DetectLostPackets(_, _, _, _))
-        .WillOnce(Return(lost_packets));
-  }
+  SendAlgorithmInterface::CongestionVector lost_packets;
+  lost_packets.push_back(std::make_pair(1, kMaxPacketSize));
+  EXPECT_CALL(*loss_algorithm_, DetectLosses(_, _, _, _))
+      .WillOnce(SetArgPointee<3>(lost_packets));
   EXPECT_CALL(*send_algorithm_, OnCongestionEvent(true, _, _, _));
   EXPECT_CALL(*send_algorithm_,
               OnPacketSent(_, _, _, packet_size - kQuicVersionSize, _));
   ProcessAckPacket(&frame);
 }
 
 TEST_P(QuicConnectionTest, QueueAfterTwoRTOs) {
   for (int i = 0; i < 10; ++i) {
     EXPECT_CALL(*send_algorithm_, OnPacketSent(_, _, _, _, _)).Times(1);
     connection_.SendStreamDataWithString(3, "foo", i * 3, !kFin, nullptr);
@@ skipping 99 matching lines @@
   }
 
   // Ack 15, nack 1-14.
 
   QuicAckFrame nack = InitAckFrame(15);
   for (int i = 1; i < 15; ++i) {
     NackPacket(i, &nack);
   }
 
   // 14 packets have been NACK'd and lost.
-  if (FLAGS_quic_general_loss_algorithm) {
-    SendAlgorithmInterface::CongestionVector lost_packets;
-    for (int i = 1; i < 15; ++i) {
-      lost_packets.push_back(std::make_pair(i, kMaxPacketSize));
-    }
-    EXPECT_CALL(*loss_algorithm_, DetectLosses(_, _, _, _))
-        .WillOnce(SetArgPointee<3>(lost_packets));
-  } else {
-    PacketNumberSet lost_packets;
-    for (int i = 1; i < 15; ++i) {
-      lost_packets.insert(i);
-    }
-    EXPECT_CALL(*loss_algorithm_, DetectLostPackets(_, _, _, _))
-        .WillOnce(Return(lost_packets));
+  SendAlgorithmInterface::CongestionVector lost_packets;
+  for (int i = 1; i < 15; ++i) {
+    lost_packets.push_back(std::make_pair(i, kMaxPacketSize));
   }
+  EXPECT_CALL(*loss_algorithm_, DetectLosses(_, _, _, _))
+      .WillOnce(SetArgPointee<3>(lost_packets));
   EXPECT_CALL(*send_algorithm_, OnCongestionEvent(true, _, _, _));
   EXPECT_CALL(*send_algorithm_, OnPacketSent(_, _, _, _, _)).Times(14);
   ProcessAckPacket(&nack);
 }
 
 // Test sending multiple acks from the connection to the session.
 TEST_P(QuicConnectionTest, MultipleAcks) {
   QuicPacketNumber last_packet;
   SendStreamDataToPeer(1, "foo", 0, !kFin, &last_packet);  // Packet 1
   EXPECT_EQ(1u, last_packet);
@@ skipping 1643 matching lines @@
 
 TEST_P(QuicConnectionTest, BundleAckWithDataOnIncomingAck) {
   EXPECT_CALL(visitor_, OnSuccessfulVersionNegotiation(_));
   connection_.SendStreamDataWithString(kClientDataStreamId1, "foo", 0, !kFin,
                                        nullptr);
   connection_.SendStreamDataWithString(kClientDataStreamId1, "foo", 3, !kFin,
                                        nullptr);
   // Ack the second packet, which will retransmit the first packet.
   QuicAckFrame ack = InitAckFrame(2);
   NackPacket(1, &ack);
-  if (FLAGS_quic_general_loss_algorithm) {
-    SendAlgorithmInterface::CongestionVector lost_packets;
-    lost_packets.push_back(std::make_pair(1, kMaxPacketSize));
-    EXPECT_CALL(*loss_algorithm_, DetectLosses(_, _, _, _))
-        .WillOnce(SetArgPointee<3>(lost_packets));
-  } else {
-    PacketNumberSet lost_packets;
-    lost_packets.insert(1);
-    EXPECT_CALL(*loss_algorithm_, DetectLostPackets(_, _, _, _))
-        .WillOnce(Return(lost_packets));
-  }
+  SendAlgorithmInterface::CongestionVector lost_packets;
+  lost_packets.push_back(std::make_pair(1, kMaxPacketSize));
+  EXPECT_CALL(*loss_algorithm_, DetectLosses(_, _, _, _))
+      .WillOnce(SetArgPointee<3>(lost_packets));
   EXPECT_CALL(*send_algorithm_, OnCongestionEvent(true, _, _, _));
   ProcessAckPacket(&ack);
   EXPECT_EQ(1u, writer_->frame_count());
   EXPECT_EQ(1u, writer_->stream_frames().size());
   writer_->Reset();
 
   // Now ack the retransmission, which will both raise the high water mark
   // and see if there is more data to send.
   ack = InitAckFrame(3);
   NackPacket(1, &ack);
-  if (FLAGS_quic_general_loss_algorithm) {
-    EXPECT_CALL(*loss_algorithm_, DetectLosses(_, _, _, _));
-  } else {
-    EXPECT_CALL(*loss_algorithm_, DetectLostPackets(_, _, _, _))
-        .WillOnce(Return(PacketNumberSet()));
-  }
+  EXPECT_CALL(*loss_algorithm_, DetectLosses(_, _, _, _));
   EXPECT_CALL(*send_algorithm_, OnCongestionEvent(true, _, _, _));
   ProcessAckPacket(&ack);
 
   // Check that no packet is sent and the ack alarm isn't set.
   EXPECT_EQ(0u, writer_->frame_count());
   EXPECT_FALSE(connection_.GetAckAlarm()->IsSet());
   writer_->Reset();
 
   // Send the same ack, but send both data and an ack together.
   ack = InitAckFrame(3);
   NackPacket(1, &ack);
-  if (FLAGS_quic_general_loss_algorithm) {
-    EXPECT_CALL(*loss_algorithm_, DetectLosses(_, _, _, _));
-  } else {
-    EXPECT_CALL(*loss_algorithm_, DetectLostPackets(_, _, _, _))
-        .WillOnce(Return(PacketNumberSet()));
-  }
+  EXPECT_CALL(*loss_algorithm_, DetectLosses(_, _, _, _));
   EXPECT_CALL(visitor_, OnCanWrite())
       .WillOnce(IgnoreResult(InvokeWithoutArgs(
           &connection_, &TestConnection::EnsureWritableAndSendStreamData5)));
   ProcessAckPacket(&ack);
 
   // Check that ack is bundled with outgoing data and the delayed ack
   // alarm is reset.
   EXPECT_EQ(3u, writer_->frame_count());
   EXPECT_FALSE(writer_->stop_waiting_frames().empty());
   EXPECT_FALSE(writer_->ack_frames().empty());
@@ skipping 342 matching lines @@
   EXPECT_CALL(*send_algorithm_, OnPacketSent(_, _, _, _, _)).Times(3);
 
   // Retransmit due to RTO.
   clock_.AdvanceTime(QuicTime::Delta::FromSeconds(10));
   connection_.GetRetransmissionAlarm()->Fire();
 
   // Retransmit due to explicit nacks.
   QuicAckFrame nack_three = InitAckFrame(4);
   NackPacket(3, &nack_three);
   NackPacket(1, &nack_three);
-  if (FLAGS_quic_general_loss_algorithm) {
-    SendAlgorithmInterface::CongestionVector lost_packets;
-    lost_packets.push_back(std::make_pair(1, kMaxPacketSize));
-    lost_packets.push_back(std::make_pair(3, kMaxPacketSize));
-    EXPECT_CALL(*loss_algorithm_, DetectLosses(_, _, _, _))
-        .WillOnce(SetArgPointee<3>(lost_packets));
-  } else {
-    PacketNumberSet lost_packets;
-    lost_packets.insert(1);
-    lost_packets.insert(3);
-    EXPECT_CALL(*loss_algorithm_, DetectLostPackets(_, _, _, _))
-        .WillOnce(Return(lost_packets));
-  }
+  SendAlgorithmInterface::CongestionVector lost_packets;
+  lost_packets.push_back(std::make_pair(1, kMaxPacketSize));
+  lost_packets.push_back(std::make_pair(3, kMaxPacketSize));
+  EXPECT_CALL(*loss_algorithm_, DetectLosses(_, _, _, _))
+      .WillOnce(SetArgPointee<3>(lost_packets));
   EXPECT_CALL(*send_algorithm_, OnCongestionEvent(true, _, _, _));
   EXPECT_CALL(visitor_, OnCanWrite());
   EXPECT_CALL(visitor_, OnSuccessfulVersionNegotiation(_));
   ProcessAckPacket(&nack_three);
 
   EXPECT_CALL(*send_algorithm_, BandwidthEstimate())
       .WillOnce(Return(QuicBandwidth::Zero()));
 
   const QuicConnectionStats& stats = connection_.GetStats();
   EXPECT_EQ(3 * first_packet_size + 2 * second_packet_size - kQuicVersionSize,
@@ skipping 167 matching lines @@
   connection_.SendStreamDataWithString(1, "foo", 0, !kFin, listener.get());
 
   // Send some other data which we will ACK.
   connection_.SendStreamDataWithString(1, "foo", 0, !kFin, nullptr);
   connection_.SendStreamDataWithString(1, "bar", 0, !kFin, nullptr);
 
   // Now we receive ACK for packets 2 and 3, but importantly missing packet 1
   // which we registered to be notified about.
   QuicAckFrame frame = InitAckFrame(3);
   NackPacket(1, &frame);
-  if (FLAGS_quic_general_loss_algorithm) {
-    SendAlgorithmInterface::CongestionVector lost_packets;
-    lost_packets.push_back(std::make_pair(1, kMaxPacketSize));
-    EXPECT_CALL(*loss_algorithm_, DetectLosses(_, _, _, _))
-        .WillOnce(SetArgPointee<3>(lost_packets));
-  } else {
-    PacketNumberSet lost_packets;
-    lost_packets.insert(1);
-    EXPECT_CALL(*loss_algorithm_, DetectLostPackets(_, _, _, _))
-        .WillOnce(Return(lost_packets));
-  }
+  SendAlgorithmInterface::CongestionVector lost_packets;
+  lost_packets.push_back(std::make_pair(1, kMaxPacketSize));
+  EXPECT_CALL(*loss_algorithm_, DetectLosses(_, _, _, _))
+      .WillOnce(SetArgPointee<3>(lost_packets));
   EXPECT_CALL(*send_algorithm_, OnCongestionEvent(true, _, _, _));
   ProcessAckPacket(&frame);
 }
 
 TEST_P(QuicConnectionTest, AckNotifierCallbackAfterRetransmission) {
   EXPECT_CALL(visitor_, OnSuccessfulVersionNegotiation(_));
 
   // Create a listener which we expect to be called.
   scoped_refptr<MockAckListener> listener(new MockAckListener);
   EXPECT_CALL(*listener, OnPacketRetransmitted(3)).Times(1);
   EXPECT_CALL(*listener, OnPacketAcked(3, _)).Times(1);
 
   // Send four packets, and register to be notified on ACK of packet 2.
   connection_.SendStreamDataWithString(3, "foo", 0, !kFin, nullptr);
   connection_.SendStreamDataWithString(3, "bar", 0, !kFin, listener.get());
   connection_.SendStreamDataWithString(3, "baz", 0, !kFin, nullptr);
   connection_.SendStreamDataWithString(3, "qux", 0, !kFin, nullptr);
 
   // Now we receive ACK for packets 1, 3, and 4 and lose 2.
   QuicAckFrame frame = InitAckFrame(4);
   NackPacket(2, &frame);
-  if (FLAGS_quic_general_loss_algorithm) {
-    SendAlgorithmInterface::CongestionVector lost_packets;
-    lost_packets.push_back(std::make_pair(2, kMaxPacketSize));
-    EXPECT_CALL(*loss_algorithm_, DetectLosses(_, _, _, _))
-        .WillOnce(SetArgPointee<3>(lost_packets));
-  } else {
-    PacketNumberSet lost_packets;
-    lost_packets.insert(2);
-    EXPECT_CALL(*loss_algorithm_, DetectLostPackets(_, _, _, _))
-        .WillOnce(Return(lost_packets));
-  }
+  SendAlgorithmInterface::CongestionVector lost_packets;
+  lost_packets.push_back(std::make_pair(2, kMaxPacketSize));
+  EXPECT_CALL(*loss_algorithm_, DetectLosses(_, _, _, _))
+      .WillOnce(SetArgPointee<3>(lost_packets));
   EXPECT_CALL(*send_algorithm_, OnCongestionEvent(true, _, _, _));
   EXPECT_CALL(*send_algorithm_, OnPacketSent(_, _, _, _, _));
   ProcessAckPacket(&frame);
 
   // Now we get an ACK for packet 5 (retransmitted packet 2), which should
   // trigger the callback.
-  if (FLAGS_quic_general_loss_algorithm) {
-    EXPECT_CALL(*loss_algorithm_, DetectLosses(_, _, _, _));
-  } else {
-    EXPECT_CALL(*loss_algorithm_, DetectLostPackets(_, _, _, _))
-        .WillOnce(Return(PacketNumberSet()));
-  }
+  EXPECT_CALL(*loss_algorithm_, DetectLosses(_, _, _, _));
   EXPECT_CALL(*send_algorithm_, OnCongestionEvent(true, _, _, _));
   QuicAckFrame second_ack_frame = InitAckFrame(5);
   ProcessAckPacket(&second_ack_frame);
 }
 
 // AckNotifierCallback is triggered by the ack of a packet that timed
 // out and was retransmitted, even though the retransmission has a
 // different packet number.
 TEST_P(QuicConnectionTest, AckNotifierCallbackForAckAfterRTO) {
   // Create a listener which we expect to be called.
@@ skipping 40 matching lines @@
   connection_.SendStreamDataWithString(3, "foo", 0, !kFin, nullptr);
   connection_.SendStreamDataWithString(3, "bar", 0, !kFin, listener.get());
   connection_.SendStreamDataWithString(3, "baz", 0, !kFin, nullptr);
   connection_.SendStreamDataWithString(3, "qux", 0, !kFin, nullptr);
 
   // Now we receive ACK for packets 1, 3, and 4 and lose 2.
   QuicAckFrame frame = InitAckFrame(4);
   NackPacket(2, &frame);
   EXPECT_CALL(*listener, OnPacketRetransmitted(_));
   EXPECT_CALL(visitor_, OnSuccessfulVersionNegotiation(_));
-  if (FLAGS_quic_general_loss_algorithm) {
-    SendAlgorithmInterface::CongestionVector lost_packets;
-    lost_packets.push_back(std::make_pair(2, kMaxPacketSize));
-    EXPECT_CALL(*loss_algorithm_, DetectLosses(_, _, _, _))
-        .WillOnce(SetArgPointee<3>(lost_packets));
-  } else {
-    PacketNumberSet lost_packets;
-    lost_packets.insert(2);
-    EXPECT_CALL(*loss_algorithm_, DetectLostPackets(_, _, _, _))
-        .WillOnce(Return(lost_packets));
-  }
+  SendAlgorithmInterface::CongestionVector lost_packets;
+  lost_packets.push_back(std::make_pair(2, kMaxPacketSize));
+  EXPECT_CALL(*loss_algorithm_, DetectLosses(_, _, _, _))
+      .WillOnce(SetArgPointee<3>(lost_packets));
   EXPECT_CALL(*send_algorithm_, OnCongestionEvent(true, _, _, _));
   EXPECT_CALL(*send_algorithm_, OnPacketSent(_, _, _, _, _));
   ProcessAckPacket(&frame);
 
   // Now we get an ACK for packet 2, which was previously nacked.
   EXPECT_CALL(*listener, OnPacketAcked(3, _));
-  if (FLAGS_quic_general_loss_algorithm) {
-    EXPECT_CALL(*loss_algorithm_, DetectLosses(_, _, _, _));
-  } else {
-    EXPECT_CALL(*loss_algorithm_, DetectLostPackets(_, _, _, _))
-        .WillOnce(Return(PacketNumberSet()));
-  }
+  EXPECT_CALL(*loss_algorithm_, DetectLosses(_, _, _, _));
   QuicAckFrame second_ack_frame = InitAckFrame(4);
   ProcessAckPacket(&second_ack_frame);
 
   // Verify that the listener is not notified again when the
   // retransmit is acked.
-  if (FLAGS_quic_general_loss_algorithm) {
-    EXPECT_CALL(*loss_algorithm_, DetectLosses(_, _, _, _));
-  } else {
-    EXPECT_CALL(*loss_algorithm_, DetectLostPackets(_, _, _, _))
-        .WillOnce(Return(PacketNumberSet()));
-  }
+  EXPECT_CALL(*loss_algorithm_, DetectLosses(_, _, _, _));
   EXPECT_CALL(*send_algorithm_, OnCongestionEvent(true, _, _, _));
   QuicAckFrame third_ack_frame = InitAckFrame(5);
   ProcessAckPacket(&third_ack_frame);
 }
 
 TEST_P(QuicConnectionTest, AckNotifierFECTriggerCallback) {
   EXPECT_CALL(visitor_, OnSuccessfulVersionNegotiation(_));
 
   // Create a listener which we expect to be called.
   scoped_refptr<MockAckListener> listener(new MockAckListener);
@@ skipping 219 matching lines @@
   // Evaluate CanWrite, and have it return a non-Zero value.
   EXPECT_CALL(*send_algorithm_, TimeUntilSend(_, _, _))
       .WillRepeatedly(Return(QuicTime::Delta::FromMilliseconds(1)));
   connection_.OnCanWrite();
   EXPECT_TRUE(connection_.GetSendAlarm()->IsSet());
   EXPECT_EQ(clock_.Now().Add(QuicTime::Delta::FromMilliseconds(1)),
             connection_.GetSendAlarm()->deadline());
 
   // Process an ack and the send alarm will be set to the  new 2ms delay.
   QuicAckFrame ack = InitAckFrame(1);
-  if (FLAGS_quic_general_loss_algorithm) {
-    EXPECT_CALL(*loss_algorithm_, DetectLosses(_, _, _, _));
-  } else {
-    EXPECT_CALL(*loss_algorithm_, DetectLostPackets(_, _, _, _))
-        .WillOnce(Return(PacketNumberSet()));
-  }
+  EXPECT_CALL(*loss_algorithm_, DetectLosses(_, _, _, _));
   EXPECT_CALL(*send_algorithm_, OnCongestionEvent(true, _, _, _));
   EXPECT_CALL(*send_algorithm_, TimeUntilSend(_, _, _))
       .WillRepeatedly(Return(QuicTime::Delta::FromMilliseconds(2)));
   ProcessAckPacket(&ack);
   EXPECT_EQ(1u, writer_->frame_count());
   EXPECT_EQ(1u, writer_->stream_frames().size());
   EXPECT_TRUE(connection_.GetSendAlarm()->IsSet());
   EXPECT_EQ(clock_.Now().Add(QuicTime::Delta::FromMilliseconds(2)),
             connection_.GetSendAlarm()->deadline());
   writer_->Reset();
@@ skipping 64 matching lines @@
   QuicStreamFrame stream_frame(1u, false, 0u, StringPiece());
   EXPECT_DFATAL(ProcessFramePacket(QuicFrame(&stream_frame)),
                 "Received a packet with multipath flag on when multipath is "
                 "not enabled.");
   EXPECT_FALSE(connection_.connected());
 }
 
 }  // namespace
 }  // namespace test
 }  // namespace net