Rename functions with same names as generator in QUIC creator. This is preparation for combining creator and generator. Not protected. gfe-relnote: n/a (functions renaming only) PiperOrigin-RevId: 269341659 Change-Id: I9dbafc0f093ee88f4769e1d407445a2b4268b8df
diff --git a/quic/core/quic_dispatcher.cc b/quic/core/quic_dispatcher.cc index b8e7f0c..a855482 100644 --- a/quic/core/quic_dispatcher.cc +++ b/quic/core/quic_dispatcher.cc
@@ -142,7 +142,7 @@ delete frame; return; } - creator_.Flush(); + creator_.FlushCurrentPacket(); DCHECK_EQ(1u, collector_.packets()->size()); time_wait_list_manager_->AddConnectionIdToTimeWait( server_connection_id_, ietf_quic,
diff --git a/quic/core/quic_packet_creator.cc b/quic/core/quic_packet_creator.cc index 4c381d4..1f985dc 100644 --- a/quic/core/quic_packet_creator.cc +++ b/quic/core/quic_packet_creator.cc
@@ -186,12 +186,13 @@ UpdatePacketNumberLength(least_packet_awaited_by_peer, max_packets_in_flight); } -bool QuicPacketCreator::ConsumeCryptoData(EncryptionLevel level, - size_t write_length, - QuicStreamOffset offset, - bool needs_full_padding, - TransmissionType transmission_type, - QuicFrame* frame) { +bool QuicPacketCreator::ConsumeCryptoDataToFillCurrentPacket( + EncryptionLevel level, + size_t write_length, + QuicStreamOffset offset, + bool needs_full_padding, + TransmissionType transmission_type, + QuicFrame* frame) { if (!CreateCryptoFrame(level, write_length, offset, frame)) { return false; } @@ -208,13 +209,14 @@ transmission_type); } -bool QuicPacketCreator::ConsumeData(QuicStreamId id, - size_t data_size, - QuicStreamOffset offset, - bool fin, - bool needs_full_padding, - TransmissionType transmission_type, - QuicFrame* frame) { +bool QuicPacketCreator::ConsumeDataToFillCurrentPacket( + QuicStreamId id, + size_t data_size, + QuicStreamOffset offset, + bool fin, + bool needs_full_padding, + TransmissionType transmission_type, + QuicFrame* frame) { if (!HasRoomForStreamFrame(id, offset, data_size)) { return false; } @@ -391,7 +393,7 @@ packet_.encryption_level = default_encryption_level; } -void QuicPacketCreator::Flush() { +void QuicPacketCreator::FlushCurrentPacket() { if (!HasPendingFrames() && pending_padding_bytes_ == 0) { return; } @@ -948,7 +950,7 @@ /* last_frame_in_packet= */ true, GetPacketNumberLength()); if (frame_len == 0) { // Current open packet is full. - Flush(); + FlushCurrentPacket(); return false; } DCHECK_LT(0u, packet_size_); @@ -1083,7 +1085,8 @@ client_connection_id_ = client_connection_id; } -void QuicPacketCreator::SetTransmissionType(TransmissionType type) { +void QuicPacketCreator::SetTransmissionTypeOfNextPackets( + TransmissionType type) { DCHECK(can_set_transmission_type_); if (!can_set_transmission_type()) {
diff --git a/quic/core/quic_packet_creator.h b/quic/core/quic_packet_creator.h index 9f00842..a3f6c00 100644 --- a/quic/core/quic_packet_creator.h +++ b/quic/core/quic_packet_creator.h
@@ -103,22 +103,22 @@ // full. // If current packet is not full, creates a stream frame that fits into the // open packet and adds it to the packet. - bool ConsumeData(QuicStreamId id, - size_t data_length, - QuicStreamOffset offset, - bool fin, - bool needs_full_padding, - TransmissionType transmission_type, - QuicFrame* frame); + bool ConsumeDataToFillCurrentPacket(QuicStreamId id, + size_t data_size, + QuicStreamOffset offset, + bool fin, + bool needs_full_padding, + TransmissionType transmission_type, + QuicFrame* frame); // Creates a CRYPTO frame that fits into the current packet (which must be // empty) and adds it to the packet. - bool ConsumeCryptoData(EncryptionLevel level, - size_t write_length, - QuicStreamOffset offset, - bool needs_full_padding, - TransmissionType transmission_type, - QuicFrame* frame); + bool ConsumeCryptoDataToFillCurrentPacket(EncryptionLevel level, + size_t write_length, + QuicStreamOffset offset, + bool needs_full_padding, + TransmissionType transmission_type, + QuicFrame* frame); // Returns true if current open packet can accommodate more stream frames of // stream |id| at |offset| and data length |data_size|, false otherwise. @@ -138,7 +138,7 @@ // Serializes all added frames into a single packet and invokes the delegate_ // to further process the SerializedPacket. - void Flush(); + void FlushCurrentPacket(); // Optimized method to create a QuicStreamFrame and serialize it. Adds the // QuicStreamFrame to the returned SerializedPacket. Sets @@ -269,7 +269,7 @@ void AddPendingPadding(QuicByteCount size); // Sets transmission type of next constructed packets. - void SetTransmissionType(TransmissionType type); + void SetTransmissionTypeOfNextPackets(TransmissionType type); // Sets the retry token to be sent over the wire in IETF Initial packets. void SetRetryToken(QuicStringPiece retry_token);
diff --git a/quic/core/quic_packet_creator_test.cc b/quic/core/quic_packet_creator_test.cc index d0cfdae..8d79cc4 100644 --- a/quic/core/quic_packet_creator_test.cc +++ b/quic/core/quic_packet_creator_test.cc
@@ -83,24 +83,24 @@ producer_(producer), version_(framer->transport_version()) {} - bool ConsumeData(QuicStreamId id, - const struct iovec* iov, - int iov_count, - size_t total_length, - size_t iov_offset, - QuicStreamOffset offset, - bool fin, - bool needs_full_padding, - TransmissionType transmission_type, - QuicFrame* frame) { + bool ConsumeDataToFillCurrentPacket(QuicStreamId id, + const struct iovec* iov, + int iov_count, + size_t total_length, + size_t iov_offset, + QuicStreamOffset offset, + bool fin, + bool needs_full_padding, + TransmissionType transmission_type, + QuicFrame* frame) { // Save data before data is consumed. QuicByteCount data_length = total_length - iov_offset; if (data_length > 0) { producer_->SaveStreamData(id, iov, iov_count, iov_offset, data_length); } - return QuicPacketCreator::ConsumeData(id, data_length - iov_offset, offset, - fin, needs_full_padding, - transmission_type, frame); + return QuicPacketCreator::ConsumeDataToFillCurrentPacket( + id, data_length - iov_offset, offset, fin, needs_full_padding, + transmission_type, frame); } void StopSendingVersion() { @@ -598,24 +598,25 @@ ProcessPacket(serialized); } -TEST_P(QuicPacketCreatorTest, ConsumeCryptoData) { +TEST_P(QuicPacketCreatorTest, ConsumeCryptoDataToFillCurrentPacket) { std::string data = "crypto data"; QuicFrame frame; - ASSERT_TRUE(creator_.ConsumeCryptoData(ENCRYPTION_INITIAL, data.length(), 0, - /*needs_full_padding=*/true, - NOT_RETRANSMISSION, &frame)); + ASSERT_TRUE(creator_.ConsumeCryptoDataToFillCurrentPacket( + ENCRYPTION_INITIAL, data.length(), 0, + /*needs_full_padding=*/true, NOT_RETRANSMISSION, &frame)); EXPECT_EQ(frame.crypto_frame->data_length, data.length()); EXPECT_TRUE(creator_.HasPendingFrames()); } -TEST_P(QuicPacketCreatorTest, ConsumeData) { +TEST_P(QuicPacketCreatorTest, ConsumeDataToFillCurrentPacket) { creator_.set_encryption_level(ENCRYPTION_FORWARD_SECURE); QuicFrame frame; MakeIOVector("test", &iov_); QuicStreamId stream_id = QuicUtils::GetFirstBidirectionalStreamId( client_framer_.transport_version(), Perspective::IS_CLIENT); - ASSERT_TRUE(creator_.ConsumeData(stream_id, &iov_, 1u, iov_.iov_len, 0u, 0u, - false, false, NOT_RETRANSMISSION, &frame)); + ASSERT_TRUE(creator_.ConsumeDataToFillCurrentPacket( + stream_id, &iov_, 1u, iov_.iov_len, 0u, 0u, false, false, + NOT_RETRANSMISSION, &frame)); size_t consumed = frame.stream_frame.data_length; EXPECT_EQ(4u, consumed); CheckStreamFrame(frame, stream_id, "test", 0u, false); @@ -628,8 +629,9 @@ MakeIOVector("test", &iov_); QuicStreamId stream_id = QuicUtils::GetFirstBidirectionalStreamId( client_framer_.transport_version(), Perspective::IS_CLIENT); - ASSERT_TRUE(creator_.ConsumeData(stream_id, &iov_, 1u, iov_.iov_len, 0u, 0u, - true, false, NOT_RETRANSMISSION, &frame)); + ASSERT_TRUE(creator_.ConsumeDataToFillCurrentPacket( + stream_id, &iov_, 1u, iov_.iov_len, 0u, 0u, true, false, + NOT_RETRANSMISSION, &frame)); size_t consumed = frame.stream_frame.data_length; EXPECT_EQ(4u, consumed); CheckStreamFrame(frame, stream_id, "test", 0u, true); @@ -641,8 +643,9 @@ QuicFrame frame; QuicStreamId stream_id = QuicUtils::GetFirstBidirectionalStreamId( client_framer_.transport_version(), Perspective::IS_CLIENT); - ASSERT_TRUE(creator_.ConsumeData(stream_id, nullptr, 0u, 0u, 0u, 0u, true, - false, NOT_RETRANSMISSION, &frame)); + ASSERT_TRUE(creator_.ConsumeDataToFillCurrentPacket( + stream_id, nullptr, 0u, 0u, 0u, 0u, true, false, NOT_RETRANSMISSION, + &frame)); size_t consumed = frame.stream_frame.data_length; EXPECT_EQ(0u, consumed); CheckStreamFrame(frame, stream_id, std::string(), 0u, true); @@ -671,12 +674,12 @@ EXPECT_CALL(delegate_, OnSerializedPacket(_)) .WillRepeatedly(Invoke( this, &QuicPacketCreatorTest::ClearSerializedPacketForTests)); - ASSERT_TRUE(creator_.ConsumeData(GetNthClientInitiatedStreamId(1), &iov_, - 1u, iov_.iov_len, 0u, kOffset, false, - false, NOT_RETRANSMISSION, &frame)); + ASSERT_TRUE(creator_.ConsumeDataToFillCurrentPacket( + GetNthClientInitiatedStreamId(1), &iov_, 1u, iov_.iov_len, 0u, + kOffset, false, false, NOT_RETRANSMISSION, &frame)); size_t bytes_consumed = frame.stream_frame.data_length; EXPECT_LT(0u, bytes_consumed); - creator_.Flush(); + creator_.FlushCurrentPacket(); } } } @@ -695,9 +698,9 @@ size_t bytes_free = delta > 0 ? 0 : 0 - delta; QuicFrame frame; MakeIOVector(data, &iov_); - ASSERT_TRUE(creator_.ConsumeData(GetNthClientInitiatedStreamId(1), &iov_, - 1u, iov_.iov_len, 0u, kOffset, false, - false, NOT_RETRANSMISSION, &frame)); + ASSERT_TRUE(creator_.ConsumeDataToFillCurrentPacket( + GetNthClientInitiatedStreamId(1), &iov_, 1u, iov_.iov_len, 0u, kOffset, + false, false, NOT_RETRANSMISSION, &frame)); // BytesFree() returns bytes available for the next frame, which will // be two bytes smaller since the stream frame would need to be grown. @@ -706,7 +709,7 @@ EXPECT_EQ(expected_bytes_free, creator_.BytesFree()) << "delta: " << delta; EXPECT_CALL(delegate_, OnSerializedPacket(_)) .WillOnce(Invoke(this, &QuicPacketCreatorTest::SaveSerializedPacket)); - creator_.Flush(); + creator_.FlushCurrentPacket(); ASSERT_TRUE(serialized_packet_.encrypted_buffer); DeleteSerializedPacket(); } @@ -740,7 +743,7 @@ .WillRepeatedly( Invoke(this, &QuicPacketCreatorTest::SaveSerializedPacket)); if (!QuicVersionUsesCryptoFrames(client_framer_.transport_version())) { - ASSERT_TRUE(creator_.ConsumeData( + ASSERT_TRUE(creator_.ConsumeDataToFillCurrentPacket( QuicUtils::GetCryptoStreamId(client_framer_.transport_version()), &iov_, 1u, iov_.iov_len, 0u, kOffset, false, true, NOT_RETRANSMISSION, &frame)); @@ -748,13 +751,13 @@ EXPECT_LT(0u, bytes_consumed); } else { producer_.SaveCryptoData(ENCRYPTION_INITIAL, kOffset, data); - ASSERT_TRUE(creator_.ConsumeCryptoData( + ASSERT_TRUE(creator_.ConsumeCryptoDataToFillCurrentPacket( ENCRYPTION_INITIAL, data.length(), kOffset, /*needs_full_padding=*/true, NOT_RETRANSMISSION, &frame)); size_t bytes_consumed = frame.crypto_frame->data_length; EXPECT_LT(0u, bytes_consumed); } - creator_.Flush(); + creator_.FlushCurrentPacket(); ASSERT_TRUE(serialized_packet_.encrypted_buffer); // If there is not enough space in the packet to fit a padding frame // (1 byte) and to expand the stream frame (another 2 bytes) the packet @@ -788,12 +791,12 @@ MakeIOVector(data, &iov_); EXPECT_CALL(delegate_, OnSerializedPacket(_)) .WillOnce(Invoke(this, &QuicPacketCreatorTest::SaveSerializedPacket)); - ASSERT_TRUE(creator_.ConsumeData(GetNthClientInitiatedStreamId(1), &iov_, - 1u, iov_.iov_len, 0u, kOffset, false, - false, NOT_RETRANSMISSION, &frame)); + ASSERT_TRUE(creator_.ConsumeDataToFillCurrentPacket( + GetNthClientInitiatedStreamId(1), &iov_, 1u, iov_.iov_len, 0u, kOffset, + false, false, NOT_RETRANSMISSION, &frame)); size_t bytes_consumed = frame.stream_frame.data_length; EXPECT_LT(0u, bytes_consumed); - creator_.Flush(); + creator_.FlushCurrentPacket(); ASSERT_TRUE(serialized_packet_.encrypted_buffer); if (bytes_free > 0) { EXPECT_EQ(kDefaultMaxPacketSize - bytes_free, @@ -1304,12 +1307,13 @@ .WillOnce(Invoke(this, &QuicPacketCreatorTest::SaveSerializedPacket)); QuicStreamId stream_id = QuicUtils::GetFirstBidirectionalStreamId( client_framer_.transport_version(), Perspective::IS_CLIENT); - ASSERT_TRUE(creator_.ConsumeData(stream_id, &iov_, 1u, iov_.iov_len, 0u, 0u, - true, false, NOT_RETRANSMISSION, &frame)); + ASSERT_TRUE(creator_.ConsumeDataToFillCurrentPacket( + stream_id, &iov_, 1u, iov_.iov_len, 0u, 0u, true, false, + NOT_RETRANSMISSION, &frame)); size_t consumed = frame.stream_frame.data_length; // The entire payload could not be consumed. EXPECT_GT(payload_length, consumed); - creator_.Flush(); + creator_.FlushCurrentPacket(); DeleteSerializedPacket(); } @@ -1353,8 +1357,9 @@ QuicFrame frame; MakeIOVector("test", &iov_); EXPECT_CALL(debug, OnFrameAddedToPacket(_)); - ASSERT_TRUE(creator_.ConsumeData(stream_id, &iov_, 1u, iov_.iov_len, 0u, 0u, - false, false, NOT_RETRANSMISSION, &frame)); + ASSERT_TRUE(creator_.ConsumeDataToFillCurrentPacket( + stream_id, &iov_, 1u, iov_.iov_len, 0u, 0u, false, false, + NOT_RETRANSMISSION, &frame)); size_t consumed = frame.stream_frame.data_length; EXPECT_EQ(4u, consumed); EXPECT_TRUE(creator_.HasPendingFrames()); @@ -1524,11 +1529,12 @@ &iov); QuicFrame frame; EXPECT_CALL(delegate_, OnUnrecoverableError(QUIC_CRYPTO_CHLO_TOO_LARGE, _)); - EXPECT_QUIC_BUG(creator_.ConsumeData(QuicUtils::GetCryptoStreamId( - client_framer_.transport_version()), - &iov, 1u, iov.iov_len, 0u, 0u, false, - false, NOT_RETRANSMISSION, &frame), - "Client hello won't fit in a single packet."); + EXPECT_QUIC_BUG( + creator_.ConsumeDataToFillCurrentPacket( + QuicUtils::GetCryptoStreamId(client_framer_.transport_version()), + &iov, 1u, iov.iov_len, 0u, 0u, false, false, NOT_RETRANSMISSION, + &frame), + "Client hello won't fit in a single packet."); } TEST_P(QuicPacketCreatorTest, PendingPadding) { @@ -1541,7 +1547,7 @@ Invoke(this, &QuicPacketCreatorTest::SaveSerializedPacket)); // Flush all paddings. while (creator_.pending_padding_bytes() > 0) { - creator_.Flush(); + creator_.FlushCurrentPacket(); { InSequence s; EXPECT_CALL(framer_visitor_, OnPacket()); @@ -1565,12 +1571,12 @@ MakeIOVector("test", &iov_); QuicStreamId stream_id = QuicUtils::GetFirstBidirectionalStreamId( client_framer_.transport_version(), Perspective::IS_CLIENT); - ASSERT_TRUE(creator_.ConsumeData( + ASSERT_TRUE(creator_.ConsumeDataToFillCurrentPacket( stream_id, &iov_, 1u, iov_.iov_len, 0u, 0u, false, /*needs_full_padding=*/true, NOT_RETRANSMISSION, &frame)); EXPECT_CALL(delegate_, OnSerializedPacket(_)) .WillOnce(Invoke(this, &QuicPacketCreatorTest::SaveSerializedPacket)); - creator_.Flush(); + creator_.FlushCurrentPacket(); EXPECT_EQ(kMaxNumRandomPaddingBytes, creator_.pending_padding_bytes()); } @@ -1647,9 +1653,10 @@ } ProcessPacket(serialized_packet_); - creator_.ConsumeData(stream_id, &iov_, 1u, iov_.iov_len, 0u, 0u, false, false, - NOT_RETRANSMISSION, &frame); - creator_.Flush(); + creator_.ConsumeDataToFillCurrentPacket(stream_id, &iov_, 1u, iov_.iov_len, + 0u, 0u, false, false, + NOT_RETRANSMISSION, &frame); + creator_.FlushCurrentPacket(); { InSequence s; EXPECT_CALL(framer_visitor_, OnPacket()); @@ -1690,22 +1697,23 @@ Invoke(this, &QuicPacketCreatorTest::SaveSerializedPacket)); // Send stream frame of size kStreamFramePayloadSize. MakeIOVector(QuicStringPiece(buf, kStreamFramePayloadSize), &iov_); - creator_.ConsumeData(stream_id, &iov_, 1u, iov_.iov_len, 0u, 0u, false, false, - NOT_RETRANSMISSION, &frame); - creator_.Flush(); + creator_.ConsumeDataToFillCurrentPacket(stream_id, &iov_, 1u, iov_.iov_len, + 0u, 0u, false, false, + NOT_RETRANSMISSION, &frame); + creator_.FlushCurrentPacket(); // 1 byte padding is sent. EXPECT_EQ(pending_padding_bytes - 1, creator_.pending_padding_bytes()); // Send stream frame of size kStreamFramePayloadSize + 1. MakeIOVector(QuicStringPiece(buf, kStreamFramePayloadSize + 1), &iov_); - creator_.ConsumeData(stream_id, &iov_, 1u, iov_.iov_len, 0u, - kStreamFramePayloadSize, false, false, - NOT_RETRANSMISSION, &frame); + creator_.ConsumeDataToFillCurrentPacket(stream_id, &iov_, 1u, iov_.iov_len, + 0u, kStreamFramePayloadSize, false, + false, NOT_RETRANSMISSION, &frame); // No padding is sent. - creator_.Flush(); + creator_.FlushCurrentPacket(); EXPECT_EQ(pending_padding_bytes - 1, creator_.pending_padding_bytes()); // Flush all paddings. while (creator_.pending_padding_bytes() > 0) { - creator_.Flush(); + creator_.FlushCurrentPacket(); } EXPECT_EQ(0u, creator_.pending_padding_bytes()); } @@ -1720,7 +1728,7 @@ MakeIOVector("test", &iov_); QuicStreamId stream_id = QuicUtils::GetFirstBidirectionalStreamId( client_framer_.transport_version(), Perspective::IS_CLIENT); - ASSERT_TRUE(creator_.ConsumeData( + ASSERT_TRUE(creator_.ConsumeDataToFillCurrentPacket( stream_id, &iov_, 1u, iov_.iov_len, 0u, 0u, false, /*needs_full_padding=*/true, NOT_RETRANSMISSION, &frame)); @@ -1729,7 +1737,7 @@ EXPECT_EQ(expected_buffer, serialized_packet->encrypted_buffer); ClearSerializedPacket(serialized_packet); })); - creator_.Flush(); + creator_.FlushCurrentPacket(); } // Test for error found in @@ -1764,7 +1772,7 @@ EXPECT_TRUE( creator_.AddSavedFrame(QuicFrame(message_frame), NOT_RETRANSMISSION)); EXPECT_TRUE(creator_.HasPendingFrames()); - creator_.Flush(); + creator_.FlushCurrentPacket(); QuicMessageFrame* frame2 = new QuicMessageFrame(2, MakeSpan(&allocator_, "message", &storage)); @@ -1776,14 +1784,15 @@ new QuicMessageFrame(3, MakeSpan(&allocator_, "message2", &storage)); EXPECT_TRUE(creator_.AddSavedFrame(QuicFrame(frame3), NOT_RETRANSMISSION)); EXPECT_EQ(1u, creator_.ExpansionOnNewFrame()); - creator_.Flush(); + creator_.FlushCurrentPacket(); QuicFrame frame; MakeIOVector("test", &iov_); QuicStreamId stream_id = QuicUtils::GetFirstBidirectionalStreamId( client_framer_.transport_version(), Perspective::IS_CLIENT); - EXPECT_TRUE(creator_.ConsumeData(stream_id, &iov_, 1u, iov_.iov_len, 0u, 0u, - false, false, NOT_RETRANSMISSION, &frame)); + EXPECT_TRUE(creator_.ConsumeDataToFillCurrentPacket( + stream_id, &iov_, 1u, iov_.iov_len, 0u, 0u, false, false, + NOT_RETRANSMISSION, &frame)); QuicMessageFrame* frame4 = new QuicMessageFrame(4, MakeSpan(&allocator_, "message", &storage)); EXPECT_TRUE(creator_.AddSavedFrame(QuicFrame(frame4), NOT_RETRANSMISSION)); @@ -1834,7 +1843,7 @@ creator_.GetCurrentLargestMessagePayload()); EXPECT_CALL(delegate_, OnSerializedPacket(_)) .WillOnce(Invoke(this, &QuicPacketCreatorTest::SaveSerializedPacket)); - creator_.Flush(); + creator_.FlushCurrentPacket(); ASSERT_TRUE(serialized_packet_.encrypted_buffer); DeleteSerializedPacket(); } @@ -1861,7 +1870,7 @@ TEST_P(QuicPacketCreatorTest, PacketTransmissionType) { creator_.set_encryption_level(ENCRYPTION_FORWARD_SECURE); creator_.set_can_set_transmission_type(true); - creator_.SetTransmissionType(NOT_RETRANSMISSION); + creator_.SetTransmissionTypeOfNextPackets(NOT_RETRANSMISSION); QuicAckFrame temp_ack_frame = InitAckFrame(1); QuicFrame ack_frame(&temp_ack_frame); @@ -1886,7 +1895,7 @@ ASSERT_FALSE(serialized_packet_.encrypted_buffer); EXPECT_TRUE(creator_.AddSavedFrame(padding_frame, TLP_RETRANSMISSION)); - creator_.Flush(); + creator_.FlushCurrentPacket(); ASSERT_TRUE(serialized_packet_.encrypted_buffer); if (creator_.can_set_transmission_type()) {
diff --git a/quic/core/quic_packet_generator.cc b/quic/core/quic_packet_generator.cc index d4e879f..14e6b63 100644 --- a/quic/core/quic_packet_generator.cc +++ b/quic/core/quic_packet_generator.cc
@@ -68,14 +68,14 @@ // should be driven by encryption level, and we should stop flushing in this // spot. if (packet_creator_.HasPendingRetransmittableFrames()) { - packet_creator_.Flush(); + packet_creator_.FlushCurrentPacket(); } size_t total_bytes_consumed = 0; while (total_bytes_consumed < write_length) { QuicFrame frame; - if (!packet_creator_.ConsumeCryptoData( + if (!packet_creator_.ConsumeCryptoDataToFillCurrentPacket( level, write_length - total_bytes_consumed, offset + total_bytes_consumed, fully_pad_crypto_handshake_packets_, next_transmission_type_, &frame)) { @@ -88,11 +88,11 @@ total_bytes_consumed += frame.crypto_frame->data_length; // TODO(ianswett): Move to having the creator flush itself when it's full. - packet_creator_.Flush(); + packet_creator_.FlushCurrentPacket(); } // Don't allow the handshake to be bundled with other retransmittable frames. - packet_creator_.Flush(); + packet_creator_.FlushCurrentPacket(); return total_bytes_consumed; } @@ -112,14 +112,14 @@ // To make reasoning about crypto frames easier, we don't combine them with // other retransmittable frames in a single packet. if (has_handshake && packet_creator_.HasPendingRetransmittableFrames()) { - packet_creator_.Flush(); + packet_creator_.FlushCurrentPacket(); } size_t total_bytes_consumed = 0; bool fin_consumed = false; if (!packet_creator_.HasRoomForStreamFrame(id, offset, write_length)) { - packet_creator_.Flush(); + packet_creator_.FlushCurrentPacket(); } if (!fin && (write_length == 0)) { @@ -139,10 +139,10 @@ bool needs_full_padding = has_handshake && fully_pad_crypto_handshake_packets_; - if (!packet_creator_.ConsumeData(id, write_length - total_bytes_consumed, - offset + total_bytes_consumed, fin, - needs_full_padding, - next_transmission_type_, &frame)) { + if (!packet_creator_.ConsumeDataToFillCurrentPacket( + id, write_length - total_bytes_consumed, + offset + total_bytes_consumed, fin, needs_full_padding, + next_transmission_type_, &frame)) { // The creator is always flushed if there's not enough room for a new // stream frame before ConsumeData, so ConsumeData should always succeed. QUIC_BUG << "Failed to ConsumeData, stream:" << id; @@ -166,7 +166,7 @@ break; } // TODO(ianswett): Move to having the creator flush itself when it's full. - packet_creator_.Flush(); + packet_creator_.FlushCurrentPacket(); run_fast_path = !has_handshake && state != FIN_AND_PADDING && !HasPendingFrames() && @@ -180,7 +180,7 @@ // Don't allow the handshake to be bundled with other retransmittable frames. if (has_handshake) { - packet_creator_.Flush(); + packet_creator_.FlushCurrentPacket(); } return QuicConsumedData(total_bytes_consumed, fin_consumed); @@ -227,7 +227,7 @@ SetMaxPacketLength(target_mtu); const bool success = packet_creator_.AddPaddedSavedFrame(frame, next_transmission_type_); - packet_creator_.Flush(); + packet_creator_.FlushCurrentPacket(); // The only reason AddFrame can fail is that the packet is too full to fit in // a ping. This is not possible for any sane MTU. DCHECK(success); @@ -248,7 +248,7 @@ } void QuicPacketGenerator::Flush() { - packet_creator_.Flush(); + packet_creator_.FlushCurrentPacket(); SendRemainingPendingPadding(); flusher_attached_ = false; if (GetQuicFlag(FLAGS_quic_export_server_num_packets_per_write_histogram)) { @@ -265,7 +265,7 @@ } void QuicPacketGenerator::FlushAllQueuedFrames() { - packet_creator_.Flush(); + packet_creator_.FlushCurrentPacket(); } bool QuicPacketGenerator::HasPendingFrames() const { @@ -372,7 +372,7 @@ while ( packet_creator_.pending_padding_bytes() > 0 && !HasPendingFrames() && delegate_->ShouldGeneratePacket(NO_RETRANSMITTABLE_DATA, NOT_HANDSHAKE)) { - packet_creator_.Flush(); + packet_creator_.FlushCurrentPacket(); } } @@ -386,7 +386,7 @@ } void QuicPacketGenerator::SetTransmissionType(TransmissionType type) { - packet_creator_.SetTransmissionType(type); + packet_creator_.SetTransmissionTypeOfNextPackets(type); if (packet_creator_.can_set_transmission_type()) { next_transmission_type_ = type; } @@ -411,7 +411,7 @@ return MESSAGE_STATUS_TOO_LARGE; } if (!packet_creator_.HasRoomForMessageFrame(message_length)) { - packet_creator_.Flush(); + packet_creator_.FlushCurrentPacket(); } QuicMessageFrame* frame = new QuicMessageFrame(message_id, message); const bool success =
diff --git a/quic/core/quic_packet_generator_test.cc b/quic/core/quic_packet_generator_test.cc index d1edfcb..6e395df 100644 --- a/quic/core/quic_packet_generator_test.cc +++ b/quic/core/quic_packet_generator_test.cc
@@ -677,7 +677,7 @@ EXPECT_TRUE(generator_.HasPendingFrames()); EXPECT_TRUE(generator_.HasRetransmittableFrames()); - creator_->Flush(); + creator_->FlushCurrentPacket(); EXPECT_FALSE(generator_.HasPendingFrames()); EXPECT_FALSE(generator_.HasRetransmittableFrames());