Let session methods that write data take argument of TransmissionType so that it's clear at which transmission type the data is written.
gfe-relnote: no behavior change. not protected.
PiperOrigin-RevId: 298673372
Change-Id: Ibe1e680be7bce0e6310f8b6db50f7f86c4c8a206
diff --git a/quic/core/http/quic_send_control_stream_test.cc b/quic/core/http/quic_send_control_stream_test.cc
index 9e72f23..a5ff591 100644
--- a/quic/core/http/quic_send_control_stream_test.cc
+++ b/quic/core/http/quic_send_control_stream_test.cc
@@ -135,7 +135,7 @@
auto save_write_data =
[&writer, this](QuicStreamId /*id*/, size_t write_length,
QuicStreamOffset offset, StreamSendingState /*state*/,
- bool /*is_retransmission*/,
+ TransmissionType /*type*/,
quiche::QuicheOptional<EncryptionLevel> /*level*/) {
send_control_stream_->WriteStreamData(offset, write_length, &writer);
return QuicConsumedData(/* bytes_consumed = */ write_length,
diff --git a/quic/core/http/quic_spdy_client_session_test.cc b/quic/core/http/quic_spdy_client_session_test.cc
index a8ddc09..dc33775 100644
--- a/quic/core/http/quic_spdy_client_session_test.cc
+++ b/quic/core/http/quic_spdy_client_session_test.cc
@@ -231,8 +231,9 @@
EXPECT_TRUE(session_->CreateOutgoingBidirectionalStream() == nullptr);
// Verify that no data may be send on existing streams.
char data[] = "hello world";
- QuicConsumedData consumed = session_->WritevData(
- stream->id(), QUICHE_ARRAYSIZE(data), 0, NO_FIN, false, QuicheNullOpt);
+ QuicConsumedData consumed =
+ session_->WritevData(stream->id(), QUICHE_ARRAYSIZE(data), 0, NO_FIN,
+ NOT_RETRANSMISSION, QuicheNullOpt);
EXPECT_FALSE(consumed.fin_consumed);
EXPECT_EQ(0u, consumed.bytes_consumed);
}
diff --git a/quic/core/http/quic_spdy_session_test.cc b/quic/core/http/quic_spdy_session_test.cc
index 37b559c..2e46a5c 100644
--- a/quic/core/http/quic_spdy_session_test.cc
+++ b/quic/core/http/quic_spdy_session_test.cc
@@ -178,8 +178,8 @@
void OnBodyAvailable() override {}
MOCK_METHOD0(OnCanWrite, void());
- MOCK_METHOD3(RetransmitStreamData,
- bool(QuicStreamOffset, QuicByteCount, bool));
+ MOCK_METHOD4(RetransmitStreamData,
+ bool(QuicStreamOffset, QuicByteCount, bool, TransmissionType));
MOCK_CONST_METHOD0(HasPendingRetransmission, bool());
};
@@ -272,13 +272,13 @@
size_t write_length,
QuicStreamOffset offset,
StreamSendingState state,
- bool is_retransmission,
+ TransmissionType type,
quiche::QuicheOptional<EncryptionLevel> level) override {
bool fin = state != NO_FIN;
QuicConsumedData consumed(write_length, fin);
if (!writev_consumes_all_data_) {
- consumed = QuicSession::WritevData(id, write_length, offset, state,
- is_retransmission, level);
+ consumed =
+ QuicSession::WritevData(id, write_length, offset, state, type, level);
}
QuicSessionPeer::GetWriteBlockedStreams(this)->UpdateBytesForStream(
id, consumed.bytes_consumed);
@@ -299,7 +299,7 @@
MakeIOVector("not empty", &iov);
QuicStreamPeer::SendBuffer(stream).SaveStreamData(&iov, 1, 0, 9);
QuicConsumedData consumed =
- WritevData(stream->id(), 9, 0, FIN, false, QuicheNullOpt);
+ WritevData(stream->id(), 9, 0, FIN, NOT_RETRANSMISSION, QuicheNullOpt);
QuicStreamPeer::SendBuffer(stream).OnStreamDataConsumed(
consumed.bytes_consumed);
return consumed;
@@ -307,7 +307,8 @@
QuicConsumedData SendLargeFakeData(QuicStream* stream, int bytes) {
DCHECK(writev_consumes_all_data_);
- return WritevData(stream->id(), bytes, 0, FIN, false, QuicheNullOpt);
+ return WritevData(stream->id(), bytes, 0, FIN, NOT_RETRANSMISSION,
+ QuicheNullOpt);
}
using QuicSession::closed_streams;
@@ -2121,11 +2122,14 @@
frames.push_back(QuicFrame(frame3));
EXPECT_FALSE(session_.WillingAndAbleToWrite());
- EXPECT_CALL(*stream2, RetransmitStreamData(_, _, _)).WillOnce(Return(true));
+ EXPECT_CALL(*stream2, RetransmitStreamData(_, _, _, _))
+ .WillOnce(Return(true));
EXPECT_CALL(*connection_, SendControlFrame(_))
.WillOnce(Invoke(&ClearControlFrame));
- EXPECT_CALL(*stream4, RetransmitStreamData(_, _, _)).WillOnce(Return(true));
- EXPECT_CALL(*stream6, RetransmitStreamData(_, _, _)).WillOnce(Return(true));
+ EXPECT_CALL(*stream4, RetransmitStreamData(_, _, _, _))
+ .WillOnce(Return(true));
+ EXPECT_CALL(*stream6, RetransmitStreamData(_, _, _, _))
+ .WillOnce(Return(true));
EXPECT_CALL(*send_algorithm, OnApplicationLimited(_));
session_.RetransmitFrames(frames, TLP_RETRANSMISSION);
}
diff --git a/quic/core/quic_control_frame_manager.cc b/quic/core/quic_control_frame_manager.cc
index e1053f1..d615582 100644
--- a/quic/core/quic_control_frame_manager.cc
+++ b/quic/core/quic_control_frame_manager.cc
@@ -8,6 +8,7 @@
#include "net/third_party/quiche/src/quic/core/quic_constants.h"
#include "net/third_party/quiche/src/quic/core/quic_session.h"
+#include "net/third_party/quiche/src/quic/core/quic_types.h"
#include "net/third_party/quiche/src/quic/platform/api/quic_bug_tracker.h"
#include "net/third_party/quiche/src/quic/platform/api/quic_flag_utils.h"
#include "net/third_party/quiche/src/quic/platform/api/quic_map_util.h"
@@ -254,7 +255,10 @@
WriteBufferedFrames();
}
-bool QuicControlFrameManager::RetransmitControlFrame(const QuicFrame& frame) {
+bool QuicControlFrameManager::RetransmitControlFrame(const QuicFrame& frame,
+ TransmissionType type) {
+ DCHECK(type == PTO_RETRANSMISSION || type == RTO_RETRANSMISSION ||
+ type == TLP_RETRANSMISSION || type == PROBING_RETRANSMISSION);
QuicControlFrameId id = GetControlFrameId(frame);
if (id == kInvalidControlFrameId) {
// Frame does not have a valid control frame ID, ignore it. Returns true
@@ -277,7 +281,7 @@
QuicFrame copy = CopyRetransmittableControlFrame(frame);
QUIC_DVLOG(1) << "control frame manager is forced to retransmit frame: "
<< frame;
- if (session_->WriteControlFrame(copy)) {
+ if (session_->WriteControlFrame(copy, type)) {
return true;
}
DeleteFrame(©);
@@ -292,7 +296,7 @@
QuicFrame frame_to_send =
control_frames_.at(least_unsent_ - least_unacked_);
QuicFrame copy = CopyRetransmittableControlFrame(frame_to_send);
- if (!session_->WriteControlFrame(copy)) {
+ if (!session_->WriteControlFrame(copy, NOT_RETRANSMISSION)) {
// Connection is write blocked.
DeleteFrame(©);
break;
@@ -305,7 +309,7 @@
while (HasPendingRetransmission()) {
QuicFrame pending = NextPendingRetransmission();
QuicFrame copy = CopyRetransmittableControlFrame(pending);
- if (!session_->WriteControlFrame(copy)) {
+ if (!session_->WriteControlFrame(copy, LOSS_RETRANSMISSION)) {
// Connection is write blocked.
DeleteFrame(©);
break;
diff --git a/quic/core/quic_control_frame_manager.h b/quic/core/quic_control_frame_manager.h
index 6ca7ea0..ffd378c 100644
--- a/quic/core/quic_control_frame_manager.h
+++ b/quic/core/quic_control_frame_manager.h
@@ -87,7 +87,7 @@
// Retransmit |frame| if it is still outstanding. Returns false if the frame
// does not get retransmitted because the connection is blocked. Otherwise,
// returns true.
- bool RetransmitControlFrame(const QuicFrame& frame);
+ bool RetransmitControlFrame(const QuicFrame& frame, TransmissionType type);
// Returns true if |frame| is outstanding and waiting to be acked. Returns
// false otherwise.
diff --git a/quic/core/quic_control_frame_manager_test.cc b/quic/core/quic_control_frame_manager_test.cc
index e76e09f..f8e9932 100644
--- a/quic/core/quic_control_frame_manager_test.cc
+++ b/quic/core/quic_control_frame_manager_test.cc
@@ -6,6 +6,7 @@
#include <utility>
+#include "net/third_party/quiche/src/quic/core/quic_types.h"
#include "net/third_party/quiche/src/quic/platform/api/quic_expect_bug.h"
#include "net/third_party/quiche/src/quic/platform/api/quic_flags.h"
#include "net/third_party/quiche/src/quic/platform/api/quic_test.h"
@@ -192,16 +193,19 @@
manager_->OnControlFrameAcked(QuicFrame(&goaway_));
// Do not retransmit an acked frame.
EXPECT_CALL(*connection_, SendControlFrame(_)).Times(0);
- EXPECT_TRUE(manager_->RetransmitControlFrame(QuicFrame(&goaway_)));
+ EXPECT_TRUE(manager_->RetransmitControlFrame(QuicFrame(&goaway_),
+ PTO_RETRANSMISSION));
// Retransmit control frame 3.
EXPECT_CALL(*connection_, SendControlFrame(_))
.WillOnce(Invoke(&ClearControlFrame));
- EXPECT_TRUE(manager_->RetransmitControlFrame(QuicFrame(&window_update_)));
+ EXPECT_TRUE(manager_->RetransmitControlFrame(QuicFrame(&window_update_),
+ PTO_RETRANSMISSION));
// Retransmit control frame 4, and connection is write blocked.
EXPECT_CALL(*connection_, SendControlFrame(_)).WillOnce(Return(false));
- EXPECT_FALSE(manager_->RetransmitControlFrame(QuicFrame(&window_update_)));
+ EXPECT_FALSE(manager_->RetransmitControlFrame(QuicFrame(&window_update_),
+ PTO_RETRANSMISSION));
}
TEST_F(QuicControlFrameManagerTest, DonotSendPingWithBufferedFrames) {
diff --git a/quic/core/quic_crypto_stream.cc b/quic/core/quic_crypto_stream.cc
index 81d8547..da5d15f 100644
--- a/quic/core/quic_crypto_stream.cc
+++ b/quic/core/quic_crypto_stream.cc
@@ -173,8 +173,8 @@
return;
}
- size_t bytes_consumed =
- stream_delegate()->WriteCryptoData(level, data.length(), offset);
+ size_t bytes_consumed = stream_delegate()->WriteCryptoData(
+ level, data.length(), offset, NOT_RETRANSMISSION);
send_buffer->OnStreamDataConsumed(bytes_consumed);
}
@@ -249,7 +249,7 @@
while (send_buffer->HasPendingRetransmission()) {
auto pending = send_buffer->NextPendingRetransmission();
size_t bytes_consumed = stream_delegate()->WriteCryptoData(
- level, pending.length, pending.offset);
+ level, pending.length, pending.offset, HANDSHAKE_RETRANSMISSION);
send_buffer->OnStreamDataRetransmitted(pending.offset, bytes_consumed);
if (bytes_consumed < pending.length) {
break;
@@ -287,7 +287,7 @@
retransmission_encryption_level);
consumed = stream_delegate()->WritevData(
id(), pending.length, pending.offset, NO_FIN,
- /*is_retransmission*/ true, QuicheNullOpt);
+ HANDSHAKE_RETRANSMISSION, QuicheNullOpt);
QUIC_DVLOG(1) << ENDPOINT << "stream " << id()
<< " tries to retransmit stream data [" << pending.offset
<< ", " << pending.offset + pending.length
@@ -302,7 +302,8 @@
} else {
QUIC_RELOADABLE_FLAG_COUNT_N(quic_writevdata_at_level, 1, 2);
consumed = RetransmitStreamDataAtLevel(pending.offset, pending.length,
- retransmission_encryption_level);
+ retransmission_encryption_level,
+ HANDSHAKE_RETRANSMISSION);
}
if (consumed.bytes_consumed < pending.length) {
// The connection is write blocked.
@@ -313,7 +314,9 @@
bool QuicCryptoStream::RetransmitStreamData(QuicStreamOffset offset,
QuicByteCount data_length,
- bool /*fin*/) {
+ bool /*fin*/,
+ TransmissionType type) {
+ DCHECK_EQ(HANDSHAKE_RETRANSMISSION, type);
QuicIntervalSet<QuicStreamOffset> retransmission(offset,
offset + data_length);
// Determine the encryption level to send data. This only needs to be once as
@@ -335,9 +338,9 @@
if (!writevdata_at_level_) {
// Set appropriate encryption level.
session()->connection()->SetDefaultEncryptionLevel(send_encryption_level);
- consumed = stream_delegate()->WritevData(
- id(), retransmission_length, retransmission_offset, NO_FIN,
- /*is_retransmission*/ true, QuicheNullOpt);
+ consumed = stream_delegate()->WritevData(id(), retransmission_length,
+ retransmission_offset, NO_FIN,
+ type, QuicheNullOpt);
QUIC_DVLOG(1) << ENDPOINT << "stream " << id()
<< " is forced to retransmit stream data ["
<< retransmission_offset << ", "
@@ -351,8 +354,9 @@
current_encryption_level);
} else {
QUIC_RELOADABLE_FLAG_COUNT_N(quic_writevdata_at_level, 2, 2);
- consumed = RetransmitStreamDataAtLevel(
- retransmission_offset, retransmission_length, send_encryption_level);
+ consumed = RetransmitStreamDataAtLevel(retransmission_offset,
+ retransmission_length,
+ send_encryption_level, type);
}
if (consumed.bytes_consumed < retransmission_length) {
// The connection is write blocked.
@@ -366,11 +370,13 @@
QuicConsumedData QuicCryptoStream::RetransmitStreamDataAtLevel(
QuicStreamOffset retransmission_offset,
QuicByteCount retransmission_length,
- EncryptionLevel encryption_level) {
+ EncryptionLevel encryption_level,
+ TransmissionType type) {
+ DCHECK_EQ(HANDSHAKE_RETRANSMISSION, type);
DCHECK(writevdata_at_level_);
const auto consumed = stream_delegate()->WritevData(
- id(), retransmission_length, retransmission_offset, NO_FIN,
- /*is_retransmission*/ true, encryption_level);
+ id(), retransmission_length, retransmission_offset, NO_FIN, type,
+ encryption_level);
QUIC_DVLOG(1) << ENDPOINT << "stream " << id()
<< " is forced to retransmit stream data ["
<< retransmission_offset << ", "
@@ -413,7 +419,8 @@
crypto_frame->offset, crypto_frame->data_length);
}
-void QuicCryptoStream::RetransmitData(QuicCryptoFrame* crypto_frame) {
+void QuicCryptoStream::RetransmitData(QuicCryptoFrame* crypto_frame,
+ TransmissionType type) {
QUIC_BUG_IF(!QuicVersionUsesCryptoFrames(session()->transport_version()))
<< "Versions less than 47 don't retransmit CRYPTO frames";
QuicIntervalSet<QuicStreamOffset> retransmission(
@@ -428,7 +435,8 @@
size_t retransmission_offset = interval.min();
size_t retransmission_length = interval.max() - interval.min();
size_t bytes_consumed = stream_delegate()->WriteCryptoData(
- crypto_frame->level, retransmission_length, retransmission_offset);
+ crypto_frame->level, retransmission_length, retransmission_offset,
+ type);
send_buffer->OnStreamDataRetransmitted(retransmission_offset,
bytes_consumed);
if (bytes_consumed < retransmission_length) {
@@ -450,7 +458,8 @@
continue;
}
size_t bytes_consumed = stream_delegate()->WriteCryptoData(
- level, data_length, send_buffer->stream_bytes_written());
+ level, data_length, send_buffer->stream_bytes_written(),
+ NOT_RETRANSMISSION);
send_buffer->OnStreamDataConsumed(bytes_consumed);
if (bytes_consumed < data_length) {
// Connection is write blocked.
diff --git a/quic/core/quic_crypto_stream.h b/quic/core/quic_crypto_stream.h
index d07a4e7..425d8c6 100644
--- a/quic/core/quic_crypto_stream.h
+++ b/quic/core/quic_crypto_stream.h
@@ -119,13 +119,15 @@
// Override to send unacked crypto data with the appropriate encryption level.
bool RetransmitStreamData(QuicStreamOffset offset,
QuicByteCount data_length,
- bool fin) override;
+ bool fin,
+ TransmissionType type) override;
// Sends stream retransmission data at |encryption_level|.
QuicConsumedData RetransmitStreamDataAtLevel(
QuicStreamOffset retransmission_offset,
QuicByteCount retransmission_length,
- EncryptionLevel encryption_level);
+ EncryptionLevel encryption_level,
+ TransmissionType type);
// Returns the number of bytes of handshake data that have been received from
// the peer in either CRYPTO or STREAM frames.
@@ -149,7 +151,7 @@
// Called to retransmit any outstanding data in the range indicated by the
// encryption level, offset, and length in |crypto_frame|.
- void RetransmitData(QuicCryptoFrame* crypto_frame);
+ void RetransmitData(QuicCryptoFrame* crypto_frame, TransmissionType type);
// Called to write buffered crypto frames.
void WriteBufferedCryptoFrames();
diff --git a/quic/core/quic_crypto_stream_test.cc b/quic/core/quic_crypto_stream_test.cc
index e3ba21c..436e572 100644
--- a/quic/core/quic_crypto_stream_test.cc
+++ b/quic/core/quic_crypto_stream_test.cc
@@ -376,10 +376,11 @@
.WillOnce(InvokeWithoutArgs([this]() {
return session_.ConsumeData(
QuicUtils::GetCryptoStreamId(connection_->transport_version()), 150,
- 1350, NO_FIN, 1350, QuicheNullOpt);
+ 1350, NO_FIN, HANDSHAKE_RETRANSMISSION, QuicheNullOpt);
}));
- EXPECT_FALSE(stream_->RetransmitStreamData(1350, 1350, false));
+ EXPECT_FALSE(stream_->RetransmitStreamData(1350, 1350, false,
+ HANDSHAKE_RETRANSMISSION));
// Verify connection's encryption level has restored.
EXPECT_EQ(ENCRYPTION_FORWARD_SECURE, connection_->encryption_level());
@@ -394,13 +395,15 @@
WritevData(QuicUtils::GetCryptoStreamId(connection_->transport_version()),
200, 2500, _, _, _))
.WillOnce(Invoke(&session_, &MockQuicSpdySession::ConsumeData));
- EXPECT_TRUE(stream_->RetransmitStreamData(1350, 1350, false));
+ EXPECT_TRUE(stream_->RetransmitStreamData(1350, 1350, false,
+ HANDSHAKE_RETRANSMISSION));
// Verify connection's encryption level has restored.
EXPECT_EQ(ENCRYPTION_FORWARD_SECURE, connection_->encryption_level());
EXPECT_CALL(session_, WritevData(_, _, _, _, _, _)).Times(0);
// Force to send an empty frame.
- EXPECT_TRUE(stream_->RetransmitStreamData(0, 0, false));
+ EXPECT_TRUE(
+ stream_->RetransmitStreamData(0, 0, false, HANDSHAKE_RETRANSMISSION));
}
TEST_F(QuicCryptoStreamTest, RetransmitStreamDataWithCryptoFrames) {
@@ -438,7 +441,7 @@
.WillOnce(Invoke(connection_,
&MockQuicConnection::QuicConnection_SendCryptoData));
QuicCryptoFrame frame_to_retransmit(ENCRYPTION_ZERO_RTT, 0, 150);
- stream_->RetransmitData(&frame_to_retransmit);
+ stream_->RetransmitData(&frame_to_retransmit, HANDSHAKE_RETRANSMISSION);
// Verify connection's encryption level has restored.
EXPECT_EQ(ENCRYPTION_FORWARD_SECURE, connection_->encryption_level());
@@ -451,14 +454,14 @@
.WillOnce(Invoke(connection_,
&MockQuicConnection::QuicConnection_SendCryptoData));
frame_to_retransmit = QuicCryptoFrame(ENCRYPTION_ZERO_RTT, 0, 1350);
- stream_->RetransmitData(&frame_to_retransmit);
+ stream_->RetransmitData(&frame_to_retransmit, HANDSHAKE_RETRANSMISSION);
// Verify connection's encryption level has restored.
EXPECT_EQ(ENCRYPTION_FORWARD_SECURE, connection_->encryption_level());
EXPECT_CALL(*connection_, SendCryptoData(_, _, _)).Times(0);
// Force to send an empty frame.
QuicCryptoFrame empty_frame(ENCRYPTION_FORWARD_SECURE, 0, 0);
- stream_->RetransmitData(&empty_frame);
+ stream_->RetransmitData(&empty_frame, HANDSHAKE_RETRANSMISSION);
}
// Regression test for b/115926584.
diff --git a/quic/core/quic_session.cc b/quic/core/quic_session.cc
index 891e6cc..26a4356 100644
--- a/quic/core/quic_session.cc
+++ b/quic/core/quic_session.cc
@@ -737,7 +737,7 @@
size_t write_length,
QuicStreamOffset offset,
StreamSendingState state,
- bool is_retransmission,
+ TransmissionType type,
quiche::QuicheOptional<EncryptionLevel> level) {
DCHECK(connection_->connected())
<< ENDPOINT << "Try to write stream data when connection is closed.";
@@ -755,7 +755,7 @@
QuicConsumedData data =
connection_->SendStreamData(id, write_length, offset, state);
- if (!is_retransmission) {
+ if (type == NOT_RETRANSMISSION) {
// This is new stream data.
write_blocked_streams_.UpdateBytesForStream(id, data.bytes_consumed);
}
@@ -770,8 +770,10 @@
size_t QuicSession::WriteCryptoData(EncryptionLevel level,
size_t write_length,
- QuicStreamOffset offset) {
+ QuicStreamOffset offset,
+ TransmissionType /*type*/) {
DCHECK(QuicVersionUsesCryptoFrames(transport_version()));
+ // TODO(b/136274541): Set the transmission type here.
const auto current_level = connection()->encryption_level();
connection_->SetDefaultEncryptionLevel(level);
const auto bytes_consumed =
@@ -781,7 +783,9 @@
return bytes_consumed;
}
-bool QuicSession::WriteControlFrame(const QuicFrame& frame) {
+bool QuicSession::WriteControlFrame(const QuicFrame& frame,
+ TransmissionType /*type*/) {
+ // TODO(b/136274541): Set the transmission type here.
return connection_->SendControlFrame(frame);
}
@@ -1956,11 +1960,11 @@
continue;
}
if (frame.type == CRYPTO_FRAME) {
- GetMutableCryptoStream()->RetransmitData(frame.crypto_frame);
+ GetMutableCryptoStream()->RetransmitData(frame.crypto_frame, type);
continue;
}
if (frame.type != STREAM_FRAME) {
- if (!control_frame_manager_.RetransmitControlFrame(frame)) {
+ if (!control_frame_manager_.RetransmitControlFrame(frame, type)) {
break;
}
continue;
@@ -1969,7 +1973,7 @@
if (stream != nullptr &&
!stream->RetransmitStreamData(frame.stream_frame.offset,
frame.stream_frame.data_length,
- frame.stream_frame.fin)) {
+ frame.stream_frame.fin, type)) {
break;
}
}
diff --git a/quic/core/quic_session.h b/quic/core/quic_session.h
index 84b1500..7f8e251 100644
--- a/quic/core/quic_session.h
+++ b/quic/core/quic_session.h
@@ -199,8 +199,9 @@
virtual void OnMessageLost(QuicMessageId message_id);
// Called by control frame manager when it wants to write control frames to
- // the peer. Returns true if |frame| is consumed, false otherwise.
- virtual bool WriteControlFrame(const QuicFrame& frame);
+ // the peer. Returns true if |frame| is consumed, false otherwise. The frame
+ // will be sent in specified transmission |type|.
+ bool WriteControlFrame(const QuicFrame& frame, TransmissionType type);
// Close the stream in both directions.
// TODO(renjietang): rename this method as it sends both RST_STREAM and
@@ -273,12 +274,13 @@
size_t write_length,
QuicStreamOffset offset,
StreamSendingState state,
- bool is_retransmission,
+ TransmissionType type,
quiche::QuicheOptional<EncryptionLevel> level) override;
size_t WriteCryptoData(EncryptionLevel level,
size_t write_length,
- QuicStreamOffset offset) override;
+ QuicStreamOffset offset,
+ TransmissionType type) override;
// Called by the QuicCryptoStream when a handshake message is sent.
virtual void OnCryptoHandshakeMessageSent(
diff --git a/quic/core/quic_session_test.cc b/quic/core/quic_session_test.cc
index 93c3a9b..152e159 100644
--- a/quic/core/quic_session_test.cc
+++ b/quic/core/quic_session_test.cc
@@ -150,8 +150,8 @@
void OnDataAvailable() override {}
MOCK_METHOD0(OnCanWrite, void());
- MOCK_METHOD3(RetransmitStreamData,
- bool(QuicStreamOffset, QuicByteCount, bool));
+ MOCK_METHOD4(RetransmitStreamData,
+ bool(QuicStreamOffset, QuicByteCount, bool, TransmissionType));
MOCK_CONST_METHOD0(HasPendingRetransmission, bool());
};
@@ -267,13 +267,13 @@
size_t write_length,
QuicStreamOffset offset,
StreamSendingState state,
- bool is_retransmission,
+ TransmissionType type,
quiche::QuicheOptional<EncryptionLevel> level) override {
bool fin = state != NO_FIN;
QuicConsumedData consumed(write_length, fin);
if (!writev_consumes_all_data_) {
- consumed = QuicSession::WritevData(id, write_length, offset, state,
- is_retransmission, level);
+ consumed =
+ QuicSession::WritevData(id, write_length, offset, state, type, level);
}
QuicSessionPeer::GetWriteBlockedStreams(this)->UpdateBytesForStream(
id, consumed.bytes_consumed);
@@ -295,8 +295,8 @@
}
MakeIOVector("not empty", &iov);
QuicStreamPeer::SendBuffer(stream).SaveStreamData(&iov, 1, 0, 9);
- QuicConsumedData consumed = WritevData(
- stream->id(), 9, 0, FIN, /*is_retransmission*/ false, QuicheNullOpt);
+ QuicConsumedData consumed =
+ WritevData(stream->id(), 9, 0, FIN, NOT_RETRANSMISSION, QuicheNullOpt);
QuicStreamPeer::SendBuffer(stream).OnStreamDataConsumed(
consumed.bytes_consumed);
return consumed;
@@ -312,8 +312,8 @@
QuicConsumedData SendLargeFakeData(QuicStream* stream, int bytes) {
DCHECK(writev_consumes_all_data_);
- return WritevData(stream->id(), bytes, 0, FIN,
- /*is_retransmission*/ false, QuicheNullOpt);
+ return WritevData(stream->id(), bytes, 0, FIN, NOT_RETRANSMISSION,
+ QuicheNullOpt);
}
bool UsesPendingStreams() const override { return uses_pending_streams_; }
@@ -2307,11 +2307,14 @@
frames.push_back(QuicFrame(frame3));
EXPECT_FALSE(session_.WillingAndAbleToWrite());
- EXPECT_CALL(*stream2, RetransmitStreamData(_, _, _)).WillOnce(Return(true));
+ EXPECT_CALL(*stream2, RetransmitStreamData(_, _, _, _))
+ .WillOnce(Return(true));
EXPECT_CALL(*connection_, SendControlFrame(_))
.WillOnce(Invoke(&ClearControlFrame));
- EXPECT_CALL(*stream4, RetransmitStreamData(_, _, _)).WillOnce(Return(true));
- EXPECT_CALL(*stream6, RetransmitStreamData(_, _, _)).WillOnce(Return(true));
+ EXPECT_CALL(*stream4, RetransmitStreamData(_, _, _, _))
+ .WillOnce(Return(true));
+ EXPECT_CALL(*stream6, RetransmitStreamData(_, _, _, _))
+ .WillOnce(Return(true));
EXPECT_CALL(*send_algorithm, OnApplicationLimited(_));
session_.RetransmitFrames(frames, TLP_RETRANSMISSION);
}
diff --git a/quic/core/quic_stream.cc b/quic/core/quic_stream.cc
index d952cc0..dbf9e66 100644
--- a/quic/core/quic_stream.cc
+++ b/quic/core/quic_stream.cc
@@ -912,7 +912,10 @@
bool QuicStream::RetransmitStreamData(QuicStreamOffset offset,
QuicByteCount data_length,
- bool fin) {
+ bool fin,
+ TransmissionType type) {
+ DCHECK(type == PTO_RETRANSMISSION || type == RTO_RETRANSMISSION ||
+ type == TLP_RETRANSMISSION || type == PROBING_RETRANSMISSION);
if (HasDeadlinePassed()) {
OnDeadlinePassed();
return true;
@@ -933,8 +936,7 @@
stream_bytes_written());
consumed = stream_delegate_->WritevData(
id_, retransmission_length, retransmission_offset,
- can_bundle_fin ? FIN : NO_FIN, /*is_retransmission*/ true,
- QuicheNullOpt);
+ can_bundle_fin ? FIN : NO_FIN, type, QuicheNullOpt);
QUIC_DVLOG(1) << ENDPOINT << "stream " << id_
<< " is forced to retransmit stream data ["
<< retransmission_offset << ", "
@@ -955,9 +957,8 @@
if (retransmit_fin) {
QUIC_DVLOG(1) << ENDPOINT << "stream " << id_
<< " retransmits fin only frame.";
- consumed =
- stream_delegate_->WritevData(id_, 0, stream_bytes_written(), FIN,
- /*is_retransmission*/ true, QuicheNullOpt);
+ consumed = stream_delegate_->WritevData(id_, 0, stream_bytes_written(), FIN,
+ type, QuicheNullOpt);
if (!consumed.fin_consumed) {
return false;
}
@@ -1027,9 +1028,9 @@
if (fin && add_random_padding_after_fin_) {
state = FIN_AND_PADDING;
}
- QuicConsumedData consumed_data = stream_delegate_->WritevData(
- id(), write_length, stream_bytes_written(), state,
- /*is_retransmission*/ false, QuicheNullOpt);
+ QuicConsumedData consumed_data =
+ stream_delegate_->WritevData(id(), write_length, stream_bytes_written(),
+ state, NOT_RETRANSMISSION, QuicheNullOpt);
OnStreamDataConsumed(consumed_data.bytes_consumed);
@@ -1103,9 +1104,9 @@
if (!send_buffer_.HasPendingRetransmission()) {
QUIC_DVLOG(1) << ENDPOINT << "stream " << id_
<< " retransmits fin only frame.";
- consumed = stream_delegate_->WritevData(
- id_, 0, stream_bytes_written(), FIN,
- /*is_retransmission*/ true, QuicheNullOpt);
+ consumed =
+ stream_delegate_->WritevData(id_, 0, stream_bytes_written(), FIN,
+ LOSS_RETRANSMISSION, QuicheNullOpt);
fin_lost_ = !consumed.fin_consumed;
if (fin_lost_) {
// Connection is write blocked.
@@ -1120,7 +1121,7 @@
(pending.offset + pending.length == stream_bytes_written());
consumed = stream_delegate_->WritevData(
id_, pending.length, pending.offset, can_bundle_fin ? FIN : NO_FIN,
- /*is_retransmission*/ true, QuicheNullOpt);
+ LOSS_RETRANSMISSION, QuicheNullOpt);
QUIC_DVLOG(1) << ENDPOINT << "stream " << id_
<< " tries to retransmit stream data [" << pending.offset
<< ", " << pending.offset + pending.length
diff --git a/quic/core/quic_stream.h b/quic/core/quic_stream.h
index 9efbe50..36aec05 100644
--- a/quic/core/quic_stream.h
+++ b/quic/core/quic_stream.h
@@ -313,10 +313,12 @@
bool fin_lost);
// Called to retransmit outstanding portion in data [offset, offset +
- // data_length) and |fin|. Returns true if all data gets retransmitted.
+ // data_length) and |fin| with Transmission |type|.
+ // Returns true if all data gets retransmitted.
virtual bool RetransmitStreamData(QuicStreamOffset offset,
QuicByteCount data_length,
- bool fin);
+ bool fin,
+ TransmissionType type);
// Sets deadline of this stream to be now + |ttl|, returns true if the setting
// succeeds.
diff --git a/quic/core/quic_stream_test.cc b/quic/core/quic_stream_test.cc
index 4055b4c..eea7b15 100644
--- a/quic/core/quic_stream_test.cc
+++ b/quic/core/quic_stream_test.cc
@@ -128,7 +128,7 @@
size_t /*write_length*/,
QuicStreamOffset /*offset*/,
StreamSendingState /*state*/,
- QuicByteCount /*bytes_written*/,
+ TransmissionType /*type*/,
quiche::QuicheOptional<EncryptionLevel> /*level*/) {
session_->CloseStream(id);
return QuicConsumedData(1, false);
@@ -304,8 +304,8 @@
// we should be write blocked a not all the data was consumed.
EXPECT_CALL(*session_, WritevData(kTestStreamId, _, _, _, _, _))
.WillOnce(InvokeWithoutArgs([this]() {
- return session_->ConsumeData(stream_->id(), 1u, 0u, NO_FIN, false,
- QuicheNullOpt);
+ return session_->ConsumeData(stream_->id(), 1u, 0u, NO_FIN,
+ NOT_RETRANSMISSION, QuicheNullOpt);
}));
stream_->WriteOrBufferData(quiche::QuicheStringPiece(kData1, 2), false,
nullptr);
@@ -323,8 +323,8 @@
// last data)
EXPECT_CALL(*session_, WritevData(kTestStreamId, _, _, _, _, _))
.WillOnce(InvokeWithoutArgs([this]() {
- return session_->ConsumeData(stream_->id(), 2u, 0u, NO_FIN, false,
- QuicheNullOpt);
+ return session_->ConsumeData(stream_->id(), 2u, 0u, NO_FIN,
+ NOT_RETRANSMISSION, QuicheNullOpt);
}));
stream_->WriteOrBufferData(quiche::QuicheStringPiece(kData1, 2), true,
nullptr);
@@ -372,7 +372,7 @@
EXPECT_CALL(*session_, WritevData(_, _, _, _, _, _))
.WillOnce(InvokeWithoutArgs([this]() {
return session_->ConsumeData(stream_->id(), kDataLen - 1, 0u, NO_FIN,
- false, QuicheNullOpt);
+ NOT_RETRANSMISSION, QuicheNullOpt);
}));
stream_->WriteOrBufferData(kData1, false, nullptr);
@@ -388,7 +388,7 @@
EXPECT_CALL(*session_, WritevData(_, _, _, _, _, _))
.WillOnce(InvokeWithoutArgs([this]() {
return session_->ConsumeData(stream_->id(), kDataLen - 1, kDataLen - 1,
- NO_FIN, false, QuicheNullOpt);
+ NO_FIN, NOT_RETRANSMISSION, QuicheNullOpt);
}));
EXPECT_CALL(*stream_, OnCanWriteNewData());
stream_->OnCanWrite();
@@ -398,7 +398,7 @@
EXPECT_CALL(*session_, WritevData(_, _, _, _, _, _))
.WillOnce(InvokeWithoutArgs([this]() {
return session_->ConsumeData(stream_->id(), 2u, 2 * kDataLen - 2,
- NO_FIN, false, QuicheNullOpt);
+ NO_FIN, NOT_RETRANSMISSION, QuicheNullOpt);
}));
EXPECT_CALL(*stream_, OnCanWriteNewData());
stream_->OnCanWrite();
@@ -444,8 +444,8 @@
// Write some data, with no FIN.
EXPECT_CALL(*session_, WritevData(kTestStreamId, _, _, _, _, _))
.WillOnce(InvokeWithoutArgs([this]() {
- return session_->ConsumeData(stream_->id(), 1u, 0u, NO_FIN, false,
- QuicheNullOpt);
+ return session_->ConsumeData(stream_->id(), 1u, 0u, NO_FIN,
+ NOT_RETRANSMISSION, QuicheNullOpt);
}));
stream_->WriteOrBufferData(quiche::QuicheStringPiece(kData1, 1), false,
nullptr);
@@ -473,8 +473,8 @@
// Write some data, with FIN.
EXPECT_CALL(*session_, WritevData(kTestStreamId, _, _, _, _, _))
.WillOnce(InvokeWithoutArgs([this]() {
- return session_->ConsumeData(stream_->id(), 1u, 0u, FIN, false,
- QuicheNullOpt);
+ return session_->ConsumeData(stream_->id(), 1u, 0u, FIN,
+ NOT_RETRANSMISSION, QuicheNullOpt);
}));
stream_->WriteOrBufferData(quiche::QuicheStringPiece(kData1, 1), true,
nullptr);
@@ -739,8 +739,8 @@
// Outgoing data with FIN.
EXPECT_CALL(*session_, WritevData(kTestStreamId, _, _, _, _, _))
.WillOnce(InvokeWithoutArgs([this]() {
- return session_->ConsumeData(stream_->id(), 2u, 0u, FIN, false,
- QuicheNullOpt);
+ return session_->ConsumeData(stream_->id(), 2u, 0u, FIN,
+ NOT_RETRANSMISSION, QuicheNullOpt);
}));
stream_->WriteOrBufferData(quiche::QuicheStringPiece(kData1, 2), true,
nullptr);
@@ -758,8 +758,8 @@
// Outgoing data with FIN.
EXPECT_CALL(*session_, WritevData(kTestStreamId, _, _, _, _, _))
.WillOnce(InvokeWithoutArgs([this]() {
- return session_->ConsumeData(stream_->id(), 2u, 0u, FIN, false,
- QuicheNullOpt);
+ return session_->ConsumeData(stream_->id(), 2u, 0u, FIN,
+ NOT_RETRANSMISSION, QuicheNullOpt);
}));
stream_->WriteOrBufferData(quiche::QuicheStringPiece(kData1, 2), true,
nullptr);
@@ -1035,8 +1035,8 @@
// Testing WriteOrBufferData.
EXPECT_CALL(*session_, WritevData(_, _, _, _, _, _))
.WillOnce(InvokeWithoutArgs([this]() {
- return session_->ConsumeData(stream_->id(), 100u, 0u, NO_FIN, false,
- QuicheNullOpt);
+ return session_->ConsumeData(stream_->id(), 100u, 0u, NO_FIN,
+ NOT_RETRANSMISSION, QuicheNullOpt);
}));
stream_->WriteOrBufferData(data, false, nullptr);
stream_->WriteOrBufferData(data, false, nullptr);
@@ -1048,8 +1048,8 @@
EXPECT_CALL(*session_, WritevData(_, _, _, _, _, _))
.WillOnce(InvokeWithoutArgs([this]() {
- return session_->ConsumeData(stream_->id(), 100, 100u, NO_FIN, false,
- QuicheNullOpt);
+ return session_->ConsumeData(stream_->id(), 100, 100u, NO_FIN,
+ NOT_RETRANSMISSION, QuicheNullOpt);
}));
// Buffered data size > threshold, do not ask upper layer for more data.
EXPECT_CALL(*stream_, OnCanWriteNewData()).Times(0);
@@ -1063,7 +1063,7 @@
EXPECT_CALL(*session_, WritevData(_, _, _, _, _, _))
.WillOnce(InvokeWithoutArgs([this, data_to_write]() {
return session_->ConsumeData(stream_->id(), data_to_write, 200u, NO_FIN,
- false, QuicheNullOpt);
+ NOT_RETRANSMISSION, QuicheNullOpt);
}));
// Buffered data size < threshold, ask upper layer for more data.
EXPECT_CALL(*stream_, OnCanWriteNewData()).Times(1);
@@ -1113,7 +1113,7 @@
EXPECT_CALL(*session_, WritevData(_, _, _, _, _, _))
.WillOnce(InvokeWithoutArgs([this, data_to_write]() {
return session_->ConsumeData(stream_->id(), data_to_write, 0u, NO_FIN,
- false, QuicheNullOpt);
+ NOT_RETRANSMISSION, QuicheNullOpt);
}));
EXPECT_CALL(*stream_, OnCanWriteNewData()).Times(1);
@@ -1174,8 +1174,8 @@
EXPECT_CALL(*session_, WritevData(_, _, _, _, _, _))
.WillOnce(InvokeWithoutArgs([this]() {
- return session_->ConsumeData(stream_->id(), 100u, 0u, NO_FIN, false,
- QuicheNullOpt);
+ return session_->ConsumeData(stream_->id(), 100u, 0u, NO_FIN,
+ NOT_RETRANSMISSION, QuicheNullOpt);
}));
// There is no buffered data before, all data should be consumed.
QuicConsumedData consumed = stream_->WriteMemSlices(span1, false);
@@ -1197,7 +1197,7 @@
EXPECT_CALL(*session_, WritevData(_, _, _, _, _, _))
.WillOnce(InvokeWithoutArgs([this, data_to_write]() {
return session_->ConsumeData(stream_->id(), data_to_write, 100u, NO_FIN,
- false, QuicheNullOpt);
+ NOT_RETRANSMISSION, QuicheNullOpt);
}));
EXPECT_CALL(*stream_, OnCanWriteNewData()).Times(1);
stream_->OnCanWrite();
@@ -1233,8 +1233,8 @@
QuicMemSliceSpan span1 = vector1.span();
EXPECT_CALL(*session_, WritevData(_, _, _, _, _, _))
.WillOnce(InvokeWithoutArgs([this]() {
- return session_->ConsumeData(stream_->id(), 5u, 0u, NO_FIN, false,
- QuicheNullOpt);
+ return session_->ConsumeData(stream_->id(), 5u, 0u, NO_FIN,
+ NOT_RETRANSMISSION, QuicheNullOpt);
}));
// There is no buffered data before, all data should be consumed.
QuicConsumedData consumed = stream_->WriteMemSlices(span1, false);
@@ -1371,8 +1371,8 @@
// be bundled with data.
EXPECT_CALL(*session_, WritevData(_, _, _, _, _, _))
.WillOnce(InvokeWithoutArgs([this]() {
- return session_->ConsumeData(stream_->id(), 9u, 18u, FIN, false,
- QuicheNullOpt);
+ return session_->ConsumeData(stream_->id(), 9u, 18u, FIN,
+ NOT_RETRANSMISSION, QuicheNullOpt);
}));
stream_->OnCanWrite();
EXPECT_FALSE(stream_->HasPendingRetransmission());
@@ -1401,8 +1401,8 @@
InSequence s;
EXPECT_CALL(*session_, WritevData(_, _, _, _, _, _))
.WillOnce(InvokeWithoutArgs([this]() {
- return session_->ConsumeData(stream_->id(), 9u, 0u, NO_FIN, false,
- QuicheNullOpt);
+ return session_->ConsumeData(stream_->id(), 9u, 0u, NO_FIN,
+ NOT_RETRANSMISSION, QuicheNullOpt);
}));
EXPECT_CALL(*session_, WritevData(_, _, _, _, _, _))
.WillOnce(Return(QuicConsumedData(0, true)));
@@ -1490,24 +1490,24 @@
// Retransmit [0, 18) with fin, and only [0, 8) is consumed.
EXPECT_CALL(*session_, WritevData(stream_->id(), 10, 0, NO_FIN, _, _))
.WillOnce(InvokeWithoutArgs([this]() {
- return session_->ConsumeData(stream_->id(), 8, 0u, NO_FIN, false,
- QuicheNullOpt);
+ return session_->ConsumeData(stream_->id(), 8, 0u, NO_FIN,
+ NOT_RETRANSMISSION, QuicheNullOpt);
}));
- EXPECT_FALSE(stream_->RetransmitStreamData(0, 18, true));
+ EXPECT_FALSE(stream_->RetransmitStreamData(0, 18, true, PTO_RETRANSMISSION));
// Retransmit [0, 18) with fin, and all is consumed.
EXPECT_CALL(*session_, WritevData(stream_->id(), 10, 0, NO_FIN, _, _))
.WillOnce(Invoke(session_.get(), &MockQuicSession::ConsumeData));
EXPECT_CALL(*session_, WritevData(stream_->id(), 5, 13, FIN, _, _))
.WillOnce(Invoke(session_.get(), &MockQuicSession::ConsumeData));
- EXPECT_TRUE(stream_->RetransmitStreamData(0, 18, true));
+ EXPECT_TRUE(stream_->RetransmitStreamData(0, 18, true, PTO_RETRANSMISSION));
// Retransmit [0, 8) with fin, and all is consumed.
EXPECT_CALL(*session_, WritevData(stream_->id(), 8, 0, NO_FIN, _, _))
.WillOnce(Invoke(session_.get(), &MockQuicSession::ConsumeData));
EXPECT_CALL(*session_, WritevData(stream_->id(), 0, 18, FIN, _, _))
.WillOnce(Invoke(session_.get(), &MockQuicSession::ConsumeData));
- EXPECT_TRUE(stream_->RetransmitStreamData(0, 8, true));
+ EXPECT_TRUE(stream_->RetransmitStreamData(0, 8, true, PTO_RETRANSMISSION));
}
TEST_P(QuicStreamTest, ResetStreamOnTtlExpiresRetransmitLostData) {
@@ -1524,7 +1524,7 @@
// Verify data gets retransmitted because TTL does not expire.
EXPECT_CALL(*session_, WritevData(stream_->id(), 100, 0, NO_FIN, _, _))
.WillOnce(Invoke(session_.get(), &MockQuicSession::ConsumeData));
- EXPECT_TRUE(stream_->RetransmitStreamData(0, 100, false));
+ EXPECT_TRUE(stream_->RetransmitStreamData(0, 100, false, PTO_RETRANSMISSION));
stream_->OnStreamFrameLost(100, 100, true);
EXPECT_TRUE(stream_->HasPendingRetransmission());
@@ -1549,7 +1549,7 @@
connection_->AdvanceTime(QuicTime::Delta::FromSeconds(1));
// Verify stream gets reset because TTL expires.
EXPECT_CALL(*session_, SendRstStream(_, QUIC_STREAM_TTL_EXPIRED, _)).Times(1);
- stream_->RetransmitStreamData(0, 100, false);
+ stream_->RetransmitStreamData(0, 100, false, PTO_RETRANSMISSION);
}
// Test that QuicStream::StopSending A) is a no-op if the connection is not in
diff --git a/quic/core/stream_delegate_interface.h b/quic/core/stream_delegate_interface.h
index 440b01a..3fc584d 100644
--- a/quic/core/stream_delegate_interface.h
+++ b/quic/core/stream_delegate_interface.h
@@ -22,18 +22,20 @@
virtual void OnStreamError(QuicErrorCode error_code,
std::string error_details) = 0;
// Called when the stream needs to write data. If |level| is present, the data
- // will be written at the specified |level|.
+ // will be written at the specified |level|. The data will be written
+ // at specified transmission |type|.
virtual QuicConsumedData WritevData(
QuicStreamId id,
size_t write_length,
QuicStreamOffset offset,
StreamSendingState state,
- bool is_retransmission,
+ TransmissionType type,
quiche::QuicheOptional<EncryptionLevel> level) = 0;
// Called to write crypto data.
virtual size_t WriteCryptoData(EncryptionLevel level,
size_t write_length,
- QuicStreamOffset offset) = 0;
+ QuicStreamOffset offset,
+ TransmissionType type) = 0;
// Called on stream creation.
virtual void RegisterStreamPriority(
QuicStreamId id,
diff --git a/quic/qbone/qbone_stream_test.cc b/quic/qbone/qbone_stream_test.cc
index df25f6b..42840be 100644
--- a/quic/qbone/qbone_stream_test.cc
+++ b/quic/qbone/qbone_stream_test.cc
@@ -45,7 +45,7 @@
size_t write_length,
QuicStreamOffset offset,
StreamSendingState state,
- bool is_retransmission,
+ TransmissionType type,
quiche::QuicheOptional<EncryptionLevel> level) override {
if (!writable_) {
return QuicConsumedData(0, false);
diff --git a/quic/quartc/quartc_stream_test.cc b/quic/quartc/quartc_stream_test.cc
index d0a527c..f1de032 100644
--- a/quic/quartc/quartc_stream_test.cc
+++ b/quic/quartc/quartc_stream_test.cc
@@ -82,7 +82,7 @@
size_t write_length,
QuicStreamOffset offset,
StreamSendingState state,
- bool /*is_retransmission*/,
+ TransmissionType /*type*/,
quiche::QuicheOptional<EncryptionLevel> /*level*/) override {
if (!writable_) {
return QuicConsumedData(0, false);
diff --git a/quic/test_tools/quic_test_utils.cc b/quic/test_tools/quic_test_utils.cc
index 680b16c..bfbf512 100644
--- a/quic/test_tools/quic_test_utils.cc
+++ b/quic/test_tools/quic_test_utils.cc
@@ -582,7 +582,7 @@
size_t write_length,
QuicStreamOffset offset,
StreamSendingState state,
- bool /*is_retransmission*/,
+ TransmissionType /*type*/,
quiche::QuicheOptional<EncryptionLevel> /*level*/) {
if (write_length > 0) {
auto buf = std::make_unique<char[]>(write_length);
@@ -656,7 +656,7 @@
size_t write_length,
QuicStreamOffset offset,
StreamSendingState state,
- bool /*is_retransmission*/,
+ TransmissionType /*type*/,
quiche::QuicheOptional<EncryptionLevel> /*level*/) {
if (write_length > 0) {
auto buf = std::make_unique<char[]>(write_length);
diff --git a/quic/test_tools/quic_test_utils.h b/quic/test_tools/quic_test_utils.h
index 7440c4d..b20f90e 100644
--- a/quic/test_tools/quic_test_utils.h
+++ b/quic/test_tools/quic_test_utils.h
@@ -638,7 +638,7 @@
size_t write_length,
QuicStreamOffset offset,
StreamSendingState state,
- bool is_retransmission,
+ TransmissionType type,
quiche::QuicheOptional<EncryptionLevel> level));
MOCK_METHOD3(SendRstStream,
@@ -669,7 +669,7 @@
size_t write_length,
QuicStreamOffset offset,
StreamSendingState state,
- bool is_retransmission,
+ TransmissionType type,
quiche::QuicheOptional<EncryptionLevel> level);
void ReallySendRstStream(QuicStreamId id,
@@ -739,7 +739,7 @@
size_t write_length,
QuicStreamOffset offset,
StreamSendingState state,
- bool is_retransmission,
+ TransmissionType type,
quiche::QuicheOptional<EncryptionLevel> level));
MOCK_METHOD3(SendRstStream,
@@ -787,7 +787,7 @@
size_t write_length,
QuicStreamOffset offset,
StreamSendingState state,
- bool is_retransmission,
+ TransmissionType type,
quiche::QuicheOptional<EncryptionLevel> level);
using QuicSession::ActivateStream;
diff --git a/quic/tools/quic_simple_server_stream_test.cc b/quic/tools/quic_simple_server_stream_test.cc
index 1c71af1..06e8866 100644
--- a/quic/tools/quic_simple_server_stream_test.cc
+++ b/quic/tools/quic_simple_server_stream_test.cc
@@ -129,7 +129,7 @@
size_t write_length,
QuicStreamOffset offset,
StreamSendingState state,
- bool is_retransmission,
+ TransmissionType type,
quiche::QuicheOptional<EncryptionLevel> level));
MOCK_METHOD4(OnStreamHeaderList,
void(QuicStreamId stream_id,
@@ -171,7 +171,7 @@
size_t write_length,
QuicStreamOffset offset,
StreamSendingState state,
- bool /*is_retransmission*/,
+ TransmissionType /*type*/,
quiche::QuicheOptional<EncryptionLevel> /*level*/) {
if (write_length > 0) {
auto buf = std::make_unique<char[]>(write_length);
