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());
