gfe-relnote: Deprecate gfe2_reloadable_flag_quic_treat_queued_packets_as_sent. PiperOrigin-RevId: 283750614 Change-Id: I4303df56680d761b4140a4c22a5e605f08ff65a1
diff --git a/quic/core/quic_connection.cc b/quic/core/quic_connection.cc index 9ecfa94..9349bf2 100644 --- a/quic/core/quic_connection.cc +++ b/quic/core/quic_connection.cc
@@ -330,9 +330,6 @@ bytes_received_before_address_validation_(0), bytes_sent_before_address_validation_(0), address_validated_(false), - treat_queued_packets_as_sent_( - GetQuicReloadableFlag(quic_treat_queued_packets_as_sent) || - version().CanSendCoalescedPackets()), quic_version_negotiated_by_default_at_server_( GetQuicReloadableFlag(quic_version_negotiated_by_default_at_server)), use_handshake_delegate_( @@ -403,15 +400,6 @@ } void QuicConnection::ClearQueuedPackets() { - for (auto it = queued_packets_.begin(); it != queued_packets_.end(); ++it) { - // Delete the buffer before calling ClearSerializedPacket, which sets - // encrypted_buffer to nullptr. - DCHECK(!treat_queued_packets_as_sent_); - delete[] it->encrypted_buffer; - ClearSerializedPacket(&(*it)); - } - queued_packets_.clear(); - buffered_packets_.clear(); } @@ -1686,28 +1674,6 @@ ScopedPacketFlusher flusher(this); packet_creator_.FlushCurrentPacket(); } - - // Remove all queued packets which only contain data for the reset stream. - // TODO(fayang): consider removing this because it should be rarely executed. - auto packet_iterator = queued_packets_.begin(); - while (packet_iterator != queued_packets_.end()) { - QuicFrames* retransmittable_frames = - &packet_iterator->retransmittable_frames; - if (retransmittable_frames->empty()) { - ++packet_iterator; - continue; - } - // NOTE THAT RemoveFramesForStream removes only STREAM frames - // for the specified stream. - RemoveFramesForStream(retransmittable_frames, id); - if (!retransmittable_frames->empty()) { - ++packet_iterator; - continue; - } - delete[] packet_iterator->encrypted_buffer; - ClearSerializedPacket(&(*packet_iterator)); - packet_iterator = queued_packets_.erase(packet_iterator); - } // TODO(ianswett): Consider checking for 3 RTOs when the last stream is // cancelled as well. } @@ -2033,37 +1999,9 @@ } QUIC_CLIENT_HISTOGRAM_COUNTS("QuicSession.NumQueuedPacketsBeforeWrite", - queued_packets_.size(), 1, 1000, 50, ""); - while (!queued_packets_.empty()) { - DCHECK(!treat_queued_packets_as_sent_); - // WritePacket() can potentially clear all queued packets, so we need to - // save the first queued packet to a local variable before calling it. - SerializedPacket packet(std::move(queued_packets_.front())); - queued_packets_.pop_front(); - - const bool write_result = WritePacket(&packet); - - if (connected_ && !write_result) { - // Write failed but connection is open, re-insert |packet| into the - // front of the queue, it will be retried later. - queued_packets_.emplace_front(std::move(packet)); - break; - } - - delete[] packet.encrypted_buffer; - ClearSerializedPacket(&packet); - if (!connected_) { - DCHECK(queued_packets_.empty()) << "Queued packets should have been " - "cleared while closing connection"; - break; - } - - // Continue to send the next packet in queue. - } + buffered_packets_.size(), 1, 1000, 50, ""); while (!buffered_packets_.empty()) { - DCHECK(treat_queued_packets_as_sent_); - QUIC_RELOADABLE_FLAG_COUNT_N(quic_treat_queued_packets_as_sent, 1, 3); if (HandleWriteBlocked()) { break; } @@ -2221,7 +2159,7 @@ QUIC_BUG << "Attempt to write packet:" << packet->packet_number << " after:" << sent_packet_manager_.GetLargestSentPacket(); QUIC_CLIENT_HISTOGRAM_COUNTS("QuicSession.NumQueuedPacketsAtOutOfOrder", - queued_packets_.size(), 1, 1000, 50, ""); + buffered_packets_.size(), 1, 1000, 50, ""); CloseConnection(QUIC_INTERNAL_ERROR, "Packet written out of order.", ConnectionCloseBehavior::SEND_CONNECTION_CLOSE_PACKET); return true; @@ -2230,13 +2168,7 @@ /*is_mtu_discovery=*/packet->encrypted_length > long_term_mtu_); // Termination packets are encrypted and saved, so don't exit early. const bool is_termination_packet = IsTerminationPacket(*packet); - if (!treat_queued_packets_as_sent_ && HandleWriteBlocked() && - !is_termination_packet) { - return false; - } - QuicPacketNumber packet_number = packet->packet_number; - QuicPacketLength encrypted_length = packet->encrypted_length; // Termination packets are eventually owned by TimeWaitListManager. // Others are deleted at the end of this call. @@ -2249,11 +2181,6 @@ char* buffer_copy = CopyBuffer(*packet); termination_packets_->emplace_back( new QuicEncryptedPacket(buffer_copy, encrypted_length, true)); - // This assures we won't try to write *forced* packets when blocked. - // Return true to stop processing. - if (!treat_queued_packets_as_sent_ && HandleWriteBlocked()) { - return true; - } } const bool looks_like_mtu_probe = packet->retransmittable_frames.empty() && @@ -2322,8 +2249,6 @@ } break; case BUFFER: - DCHECK(treat_queued_packets_as_sent_); - QUIC_RELOADABLE_FLAG_COUNT_N(quic_treat_queued_packets_as_sent, 2, 3); QUIC_DVLOG(1) << ENDPOINT << "Adding packet: " << packet->packet_number << " to buffered packets"; buffered_packets_.emplace_back(*packet, self_address(), peer_address()); @@ -2358,14 +2283,9 @@ // duplicate packet being sent. The helper must call OnCanWrite // when the write completes, and OnWriteError if an error occurs. if (result.status != WRITE_STATUS_BLOCKED_DATA_BUFFERED) { - if (treat_queued_packets_as_sent_) { - QUIC_RELOADABLE_FLAG_COUNT_N(quic_treat_queued_packets_as_sent, 3, 3); - QUIC_DVLOG(1) << ENDPOINT << "Adding packet: " << packet->packet_number - << " to buffered packets"; - buffered_packets_.emplace_back(*packet, self_address(), peer_address()); - } else { - return false; - } + QUIC_DVLOG(1) << ENDPOINT << "Adding packet: " << packet->packet_number + << " to buffered packets"; + buffered_packets_.emplace_back(*packet, self_address(), peer_address()); } } @@ -2626,17 +2546,7 @@ QUIC_BUG << "packet.encrypted_buffer == nullptr in to SendOrQueuePacket"; return; } - // If there are already queued packets, queue this one immediately to ensure - // it's written in sequence number order. - if (!queued_packets_.empty() || !WritePacket(packet)) { - if (!treat_queued_packets_as_sent_) { - // Take ownership of the underlying encrypted packet. - packet->encrypted_buffer = CopyBuffer(*packet); - queued_packets_.push_back(*packet); - packet->retransmittable_frames.clear(); - } - } - + WritePacket(packet); ClearSerializedPacket(packet); } @@ -3089,15 +2999,14 @@ } bool QuicConnection::HasQueuedData() const { - return pending_version_negotiation_packet_ || !queued_packets_.empty() || + return pending_version_negotiation_packet_ || packet_creator_.HasPendingFrames() || !buffered_packets_.empty(); } bool QuicConnection::CanWriteStreamData() { // Don't write stream data if there are negotiation or queued data packets // to send. Otherwise, continue and bundle as many frames as possible. - if (pending_version_negotiation_packet_ || !queued_packets_.empty() || - !buffered_packets_.empty()) { + if (pending_version_negotiation_packet_ || !buffered_packets_.empty()) { return false; } @@ -3700,9 +3609,8 @@ return; } - bool application_limited = queued_packets_.empty() && - buffered_packets_.empty() && - !visitor_->WillingAndAbleToWrite(); + bool application_limited = + buffered_packets_.empty() && !visitor_->WillingAndAbleToWrite(); if (!application_limited) { return; @@ -4087,9 +3995,6 @@ SerializedPacketFate QuicConnection::DeterminePacketFate( bool is_mtu_discovery) { - if (!treat_queued_packets_as_sent_) { - return SEND_TO_WRITER; - } if (version().CanSendCoalescedPackets() && sent_packet_manager_.handshake_state() < QuicSentPacketManager::HANDSHAKE_CONFIRMED &&
diff --git a/quic/core/quic_connection.h b/quic/core/quic_connection.h index 2fcc604..abd836f 100644 --- a/quic/core/quic_connection.h +++ b/quic/core/quic_connection.h
@@ -599,12 +599,7 @@ } // Testing only. - size_t NumQueuedPackets() const { - if (treat_queued_packets_as_sent_) { - return buffered_packets_.size(); - } - return queued_packets_.size(); - } + size_t NumQueuedPackets() const { return buffered_packets_.size(); } // Returns true if the underlying UDP socket is writable, there is // no queued data and the connection is not congestion-control @@ -893,10 +888,6 @@ // or the one sent after an IETF Retry. void InstallInitialCrypters(QuicConnectionId connection_id); - bool treat_queued_packets_as_sent() const { - return treat_queued_packets_as_sent_; - } - // Called when version is considered negotiated. void OnSuccessfulVersionNegotiation(); @@ -1285,15 +1276,6 @@ bool send_ietf_version_negotiation_packet_; bool send_version_negotiation_packet_with_prefixed_lengths_; - // When packets could not be sent because the socket was not writable, - // they are added to this list. All corresponding frames are in - // unacked_packets_ if they are to be retransmitted. Packets encrypted_buffer - // fields are owned by the QueuedPacketList, in order to ensure they outlast - // the original scope of the SerializedPacket. - // TODO(fayang): Remove this when deprecating - // quic_treat_queued_packets_as_sent. - QueuedPacketList queued_packets_; - // Contains the connection close packets if the connection has been closed. std::unique_ptr<std::vector<std::unique_ptr<QuicEncryptedPacket>>> termination_packets_; @@ -1510,8 +1492,7 @@ // Used to store content of packets which cannot be sent because of write // blocked. Packets' encrypted buffers are copied and owned by // buffered_packets_. From unacked_packet_map (and congestion control)'s - // perspective, those packets are considered sent. This is only used when - // treat_queued_packets_as_sent_ is true. + // perspective, those packets are considered sent. std::list<BufferedPacket> buffered_packets_; // Used to coalesce packets of different encryption level into the same UDP @@ -1519,9 +1500,6 @@ // packet gets acknowledged. QuicCoalescedPacket coalesced_packet_; - // Latched value of quic_treat_queued_packets_as_sent. - const bool treat_queued_packets_as_sent_; - QuicConnectionMtuDiscoverer mtu_discoverer_; // Latched value of quic_version_negotiated_by_default_at_server.
diff --git a/quic/core/quic_connection_test.cc b/quic/core/quic_connection_test.cc index 37d3d36..3babced 100644 --- a/quic/core/quic_connection_test.cc +++ b/quic/core/quic_connection_test.cc
@@ -2034,21 +2034,8 @@ writer_->SetWritable(); connection_.SendConnectivityProbingPacket(writer_.get(), connection_.peer_address()); - if (connection_.treat_queued_packets_as_sent()) { - EXPECT_CALL(visitor_, OnConnectionClosed(_, _)).Times(0); - connection_.OnCanWrite(); - return; - } - EXPECT_CALL(visitor_, - OnConnectionClosed(_, ConnectionCloseSource::FROM_SELF)); - EXPECT_QUIC_BUG(connection_.OnCanWrite(), - "Attempt to write packet:1 after:2"); - EXPECT_FALSE(connection_.connected()); - TestConnectionCloseQuicErrorCode(QUIC_INTERNAL_ERROR); - const std::vector<QuicConnectionCloseFrame>& connection_close_frames = - writer_->connection_close_frames(); - EXPECT_EQ("Packet written out of order.", - connection_close_frames[0].error_details); + EXPECT_CALL(visitor_, OnConnectionClosed(_, _)).Times(0); + connection_.OnCanWrite(); } TEST_P(QuicConnectionTest, DiscardQueuedPacketsAfterConnectionClose) { @@ -2070,12 +2057,8 @@ connection_.SendStreamDataWithString(/*id=*/2, "foo", 0, NO_FIN); EXPECT_FALSE(connection_.connected()); - if (connection_.treat_queued_packets_as_sent()) { - // No need to buffer packets. - EXPECT_EQ(0u, connection_.NumQueuedPackets()); - } else { - EXPECT_EQ(1u, connection_.NumQueuedPackets()); - } + // No need to buffer packets. + EXPECT_EQ(0u, connection_.NumQueuedPackets()); EXPECT_EQ(0u, connection_.GetStats().packets_discarded); connection_.OnCanWrite(); @@ -3371,11 +3354,7 @@ BlockOnNextWrite(); QuicStreamId stream_id = 2; - if (connection_.treat_queued_packets_as_sent()) { - EXPECT_CALL(*send_algorithm_, OnPacketSent(_, _, _, _, _)).Times(1); - } else { - EXPECT_CALL(*send_algorithm_, OnPacketSent(_, _, _, _, _)).Times(0); - } + EXPECT_CALL(*send_algorithm_, OnPacketSent(_, _, _, _, _)).Times(1); connection_.SendStreamDataWithString(stream_id, "foo", 0, NO_FIN); // Now that there is a queued packet, reset the stream. @@ -3383,13 +3362,7 @@ // Unblock the connection and verify that the RST_STREAM is sent and the data // packet is sent. - if (connection_.treat_queued_packets_as_sent()) { - EXPECT_CALL(*send_algorithm_, OnPacketSent(_, _, _, _, _)) - .Times(AtLeast(1)); - } else { - EXPECT_CALL(*send_algorithm_, OnPacketSent(_, _, _, _, _)) - .Times(AtLeast(2)); - } + EXPECT_CALL(*send_algorithm_, OnPacketSent(_, _, _, _, _)).Times(AtLeast(1)); writer_->SetWritable(); connection_.OnCanWrite(); size_t padding_frame_count = writer_->padding_frames().size(); @@ -3588,12 +3561,8 @@ EXPECT_CALL(*loss_algorithm_, DetectLosses(_, _, _, _, _, _)) .WillOnce(SetArgPointee<5>(lost_packets)); EXPECT_CALL(*send_algorithm_, OnCongestionEvent(true, _, _, _, _)); - if (connection_.treat_queued_packets_as_sent()) { - EXPECT_CALL(*send_algorithm_, OnPacketSent(_, _, QuicPacketNumber(4), _, _)) - .Times(1); - } else { - EXPECT_CALL(*send_algorithm_, OnPacketSent(_, _, _, _, _)).Times(0); - } + EXPECT_CALL(*send_algorithm_, OnPacketSent(_, _, QuicPacketNumber(4), _, _)) + .Times(1); ProcessAckPacket(&nack_two); EXPECT_EQ(1u, connection_.NumQueuedPackets()); @@ -3603,15 +3572,8 @@ QuicAckFrame ack_all = InitAckFrame(3); ProcessAckPacket(&ack_all); - if (connection_.treat_queued_packets_as_sent()) { - EXPECT_CALL(*send_algorithm_, OnPacketSent(_, _, QuicPacketNumber(4), _, _)) - .Times(0); - } else { - // Unblock the socket and attempt to send the queued packets. We will always - // send the retransmission. - EXPECT_CALL(*send_algorithm_, OnPacketSent(_, _, QuicPacketNumber(4), _, _)) - .Times(1); - } + EXPECT_CALL(*send_algorithm_, OnPacketSent(_, _, QuicPacketNumber(4), _, _)) + .Times(0); writer_->SetWritable(); connection_.OnCanWrite(); @@ -3662,11 +3624,7 @@ // Block the writer and ensure they're queued. BlockOnNextWrite(); clock_.AdvanceTime(DefaultRetransmissionTime()); - if (connection_.treat_queued_packets_as_sent()) { - EXPECT_CALL(*send_algorithm_, OnPacketSent(_, _, _, _, _)).Times(2); - } else { - EXPECT_CALL(*send_algorithm_, OnPacketSent(_, _, _, _, _)).Times(0); - } + EXPECT_CALL(*send_algorithm_, OnPacketSent(_, _, _, _, _)).Times(2); connection_.GetRetransmissionAlarm()->Fire(); EXPECT_TRUE(connection_.HasQueuedData()); @@ -3674,12 +3632,7 @@ writer_->SetWritable(); clock_.AdvanceTime(QuicTime::Delta::FromMicroseconds( 2 * DefaultRetransmissionTime().ToMicroseconds())); - if (connection_.treat_queued_packets_as_sent()) { - EXPECT_CALL(*send_algorithm_, OnPacketSent(_, _, _, _, _)).Times(2); - } else { - // 2 RTOs + 1 TLP, which is buggy. - EXPECT_CALL(*send_algorithm_, OnPacketSent(_, _, _, _, _)).Times(3); - } + EXPECT_CALL(*send_algorithm_, OnPacketSent(_, _, _, _, _)).Times(2); connection_.GetRetransmissionAlarm()->Fire(); connection_.OnCanWrite(); } @@ -3699,36 +3652,20 @@ TEST_P(QuicConnectionTest, WriteBlockedThenSent) { EXPECT_CALL(*send_algorithm_, OnPacketSent(_, _, _, _, _)).Times(0); BlockOnNextWrite(); - if (connection_.treat_queued_packets_as_sent()) { - EXPECT_CALL(*send_algorithm_, OnPacketSent(_, _, _, _, _)).Times(1); - } else { - EXPECT_CALL(*send_algorithm_, OnPacketSent(_, _, _, _, _)).Times(0); - } + EXPECT_CALL(*send_algorithm_, OnPacketSent(_, _, _, _, _)).Times(1); connection_.SendStreamDataWithString(1, "foo", 0, NO_FIN); - if (connection_.treat_queued_packets_as_sent()) { - EXPECT_TRUE(connection_.GetRetransmissionAlarm()->IsSet()); - } else { - EXPECT_FALSE(connection_.GetRetransmissionAlarm()->IsSet()); - } + EXPECT_TRUE(connection_.GetRetransmissionAlarm()->IsSet()); EXPECT_EQ(1u, connection_.NumQueuedPackets()); // The second packet should also be queued, in order to ensure packets are // never sent out of order. writer_->SetWritable(); - if (connection_.treat_queued_packets_as_sent()) { - EXPECT_CALL(*send_algorithm_, OnPacketSent(_, _, _, _, _)).Times(1); - } else { - EXPECT_CALL(*send_algorithm_, OnPacketSent(_, _, _, _, _)).Times(0); - } + EXPECT_CALL(*send_algorithm_, OnPacketSent(_, _, _, _, _)).Times(1); connection_.SendStreamDataWithString(1, "foo", 0, NO_FIN); EXPECT_EQ(2u, connection_.NumQueuedPackets()); // Now both are sent in order when we unblock. - if (connection_.treat_queued_packets_as_sent()) { - EXPECT_CALL(*send_algorithm_, OnPacketSent(_, _, _, _, _)).Times(0); - } else { - EXPECT_CALL(*send_algorithm_, OnPacketSent(_, _, _, _, _)).Times(2); - } + EXPECT_CALL(*send_algorithm_, OnPacketSent(_, _, _, _, _)).Times(0); connection_.OnCanWrite(); EXPECT_TRUE(connection_.GetRetransmissionAlarm()->IsSet()); EXPECT_EQ(0u, connection_.NumQueuedPackets()); @@ -4299,11 +4236,7 @@ // Simulate the retransmission alarm firing and the socket blocking. BlockOnNextWrite(); clock_.AdvanceTime(DefaultRetransmissionTime()); - if (connection_.treat_queued_packets_as_sent()) { - EXPECT_CALL(*send_algorithm_, OnPacketSent(_, _, _, _, _)).Times(1); - } else { - EXPECT_CALL(*send_algorithm_, OnPacketSent(_, _, _, _, _)).Times(0); - } + EXPECT_CALL(*send_algorithm_, OnPacketSent(_, _, _, _, _)).Times(1); connection_.GetRetransmissionAlarm()->Fire(); EXPECT_EQ(1u, connection_.NumQueuedPackets()); @@ -4453,26 +4386,13 @@ TEST_P(QuicConnectionTest, SetRTOAfterWritingToSocket) { BlockOnNextWrite(); - if (connection_.treat_queued_packets_as_sent()) { - EXPECT_CALL(*send_algorithm_, OnPacketSent(_, _, _, _, _)).Times(1); - } else { - EXPECT_CALL(*send_algorithm_, OnPacketSent(_, _, _, _, _)).Times(0); - } + EXPECT_CALL(*send_algorithm_, OnPacketSent(_, _, _, _, _)).Times(1); connection_.SendStreamDataWithString(1, "foo", 0, NO_FIN); - if (connection_.treat_queued_packets_as_sent()) { - EXPECT_TRUE(connection_.GetRetransmissionAlarm()->IsSet()); - } else { - // Make sure that RTO is not started when the packet is queued. - EXPECT_FALSE(connection_.GetRetransmissionAlarm()->IsSet()); - } + EXPECT_TRUE(connection_.GetRetransmissionAlarm()->IsSet()); // Test that RTO is started once we write to the socket. writer_->SetWritable(); - if (connection_.treat_queued_packets_as_sent()) { - EXPECT_CALL(*send_algorithm_, OnPacketSent(_, _, _, _, _)).Times(0); - } else { - EXPECT_CALL(*send_algorithm_, OnPacketSent(_, _, _, _, _)).Times(1); - } + EXPECT_CALL(*send_algorithm_, OnPacketSent(_, _, _, _, _)).Times(0); connection_.OnCanWrite(); EXPECT_TRUE(connection_.GetRetransmissionAlarm()->IsSet()); } @@ -4969,9 +4889,7 @@ SendStreamDataToPeer(3, "!", packets_between_probes_base - 1, NO_FIN, nullptr); ASSERT_TRUE(connection_.GetMtuDiscoveryAlarm()->IsSet()); - if (GetQuicReloadableFlag(quic_treat_queued_packets_as_sent)) { - EXPECT_CALL(*send_algorithm_, OnPacketSent(_, _, _, _, _)); - } + EXPECT_CALL(*send_algorithm_, OnPacketSent(_, _, _, _, _)); BlockOnNextWrite(); EXPECT_EQ(0u, connection_.NumQueuedPackets()); connection_.GetMtuDiscoveryAlarm()->Fire(); @@ -7982,11 +7900,7 @@ EXPECT_CALL(visitor_, WillingAndAbleToWrite()).WillRepeatedly(Return(true)); BlockOnNextWrite(); - if (connection_.treat_queued_packets_as_sent()) { - EXPECT_CALL(*send_algorithm_, OnPacketSent(_, _, _, _, _)).Times(1); - } else { - EXPECT_CALL(*send_algorithm_, OnPacketSent(_, _, _, _, _)).Times(0); - } + EXPECT_CALL(*send_algorithm_, OnPacketSent(_, _, _, _, _)).Times(1); connection_.SendStreamData3(); // Now unblock the writer, become congestion control blocked, @@ -7994,11 +7908,7 @@ writer_->SetWritable(); CongestionBlockWrites(); EXPECT_CALL(visitor_, WillingAndAbleToWrite()).WillRepeatedly(Return(false)); - if (connection_.treat_queued_packets_as_sent()) { - EXPECT_CALL(*send_algorithm_, OnPacketSent(_, _, _, _, _)).Times(0); - } else { - EXPECT_CALL(*send_algorithm_, OnPacketSent(_, _, _, _, _)).Times(1); - } + EXPECT_CALL(*send_algorithm_, OnPacketSent(_, _, _, _, _)).Times(0); EXPECT_CALL(*send_algorithm_, OnApplicationLimited(_)).Times(1); connection_.OnCanWrite(); } @@ -8682,32 +8592,15 @@ TEST_P(QuicConnectionTest, WriteBlockedWithInvalidAck) { EXPECT_CALL(visitor_, OnSuccessfulVersionNegotiation(_)); - if (connection_.treat_queued_packets_as_sent()) { - EXPECT_CALL(visitor_, OnConnectionClosed(_, _)).Times(0); - } else { - EXPECT_CALL(visitor_, OnConnectionClosed(_, _)) - .WillOnce(Invoke(this, &QuicConnectionTest::SaveConnectionCloseFrame)); - } + EXPECT_CALL(visitor_, OnConnectionClosed(_, _)).Times(0); BlockOnNextWrite(); - if (connection_.treat_queued_packets_as_sent()) { - EXPECT_CALL(*send_algorithm_, OnPacketSent(_, _, _, _, _)).Times(1); - } else { - EXPECT_CALL(*send_algorithm_, OnPacketSent(_, _, _, _, _)).Times(0); - } + EXPECT_CALL(*send_algorithm_, OnPacketSent(_, _, _, _, _)).Times(1); connection_.SendStreamDataWithString(5, "foo", 0, FIN); // This causes connection to be closed because packet 1 has not been sent yet. QuicAckFrame frame = InitAckFrame(1); - if (connection_.treat_queued_packets_as_sent()) { - EXPECT_CALL(*send_algorithm_, OnCongestionEvent(_, _, _, _, _)); - } + EXPECT_CALL(*send_algorithm_, OnCongestionEvent(_, _, _, _, _)); ProcessAckPacket(1, &frame); - if (connection_.treat_queued_packets_as_sent()) { - EXPECT_EQ(0, connection_close_frame_count_); - } else { - EXPECT_EQ(1, connection_close_frame_count_); - EXPECT_THAT(saved_connection_close_frame_.quic_error_code, - IsError(QUIC_INVALID_ACK_DATA)); - } + EXPECT_EQ(0, connection_close_frame_count_); } TEST_P(QuicConnectionTest, SendMessage) { @@ -9361,11 +9254,7 @@ EXPECT_CALL(visitor_, OnWriteBlocked()).Times(AtLeast(1)); SendRstStream(stream_id, QUIC_ERROR_PROCESSING_STREAM, 3); - if (connection_.treat_queued_packets_as_sent()) { - EXPECT_CALL(*send_algorithm_, OnPacketSent(_, _, _, _, _)).Times(1); - } else { - EXPECT_CALL(*send_algorithm_, OnPacketSent(_, _, _, _, _)).Times(0); - } + EXPECT_CALL(*send_algorithm_, OnPacketSent(_, _, _, _, _)).Times(1); // Retransmission timer fires in TLP mode. connection_.GetRetransmissionAlarm()->Fire(); // Verify one packets is forced flushed when writer is blocked.