Refactor PerPacketOptions for QuicWriter. From the bug:
per_packet_options_ was originally designed as a vehicle for platforms to get specific instructions to their corresponding QuicWriters via a QuicConnection that didn't understand the semantics of those instructions. Therefore, it is passed to QuicConnection as a piece of memory of which the platform retains ownership.
Over time, other instructions specific to QuicConnection have appeared in this struct, as it provides a vehicle to send information to QuicWriter without changing APIs. But this violates the intent of the struct, makes Quiche functions reliant on a piece of memory owned by the platform, and is bug prone (e.g., if the platform provides the same piece of memory for all connections in a dispatcher, the outcome will be very bad).
PiperOrigin-RevId: 534577370
diff --git a/quiche/quic/core/batch_writer/quic_batch_writer_base.cc b/quiche/quic/core/batch_writer/quic_batch_writer_base.cc
index 4a94c71..fae805f 100644
--- a/quiche/quic/core/batch_writer/quic_batch_writer_base.cc
+++ b/quiche/quic/core/batch_writer/quic_batch_writer_base.cc
@@ -18,9 +18,10 @@
WriteResult QuicBatchWriterBase::WritePacket(
const char* buffer, size_t buf_len, const QuicIpAddress& self_address,
- const QuicSocketAddress& peer_address, PerPacketOptions* options) {
- const WriteResult result =
- InternalWritePacket(buffer, buf_len, self_address, peer_address, options);
+ const QuicSocketAddress& peer_address, PerPacketOptions* options,
+ const QuicPacketWriterParams& params) {
+ const WriteResult result = InternalWritePacket(buffer, buf_len, self_address,
+ peer_address, options, params);
if (IsWriteBlockedStatus(result.status)) {
write_blocked_ = true;
@@ -31,14 +32,15 @@
WriteResult QuicBatchWriterBase::InternalWritePacket(
const char* buffer, size_t buf_len, const QuicIpAddress& self_address,
- const QuicSocketAddress& peer_address, PerPacketOptions* options) {
+ const QuicSocketAddress& peer_address, PerPacketOptions* options,
+ const QuicPacketWriterParams& params) {
if (buf_len > kMaxOutgoingPacketSize) {
return WriteResult(WRITE_STATUS_MSG_TOO_BIG, EMSGSIZE);
}
ReleaseTime release_time{0, QuicTime::Delta::Zero()};
if (SupportsReleaseTime()) {
- release_time = GetReleaseTime(options);
+ release_time = GetReleaseTime(params);
if (release_time.release_time_offset >= QuicTime::Delta::Zero()) {
QUIC_SERVER_HISTOGRAM_TIMES(
"batch_writer_positive_release_time_offset",
@@ -55,7 +57,7 @@
}
const CanBatchResult can_batch_result =
- CanBatch(buffer, buf_len, self_address, peer_address, options,
+ CanBatch(buffer, buf_len, self_address, peer_address, options, params,
release_time.actual_release_time);
bool buffered = false;
@@ -64,7 +66,7 @@
if (can_batch_result.can_batch) {
QuicBatchWriterBuffer::PushResult push_result =
batch_buffer_->PushBufferedWrite(buffer, buf_len, self_address,
- peer_address, options,
+ peer_address, options, params,
release_time.actual_release_time);
if (push_result.succeeded) {
buffered = true;
@@ -111,7 +113,7 @@
if (!buffered) {
QuicBatchWriterBuffer::PushResult push_result =
batch_buffer_->PushBufferedWrite(buffer, buf_len, self_address,
- peer_address, options,
+ peer_address, options, params,
release_time.actual_release_time);
buffered = push_result.succeeded;
diff --git a/quiche/quic/core/batch_writer/quic_batch_writer_base.h b/quiche/quic/core/batch_writer/quic_batch_writer_base.h
index a5a1e38..a33b8e2 100644
--- a/quiche/quic/core/batch_writer/quic_batch_writer_base.h
+++ b/quiche/quic/core/batch_writer/quic_batch_writer_base.h
@@ -32,7 +32,8 @@
WriteResult WritePacket(const char* buffer, size_t buf_len,
const QuicIpAddress& self_address,
const QuicSocketAddress& peer_address,
- PerPacketOptions* options) override;
+ PerPacketOptions* options,
+ const QuicPacketWriterParams& params) override;
bool IsWriteBlocked() const final { return write_blocked_; }
@@ -78,7 +79,7 @@
QuicTime::Delta release_time_offset = QuicTime::Delta::Zero();
};
virtual ReleaseTime GetReleaseTime(
- const PerPacketOptions* /*options*/) const {
+ const QuicPacketWriterParams& /*params*/) const {
QUICHE_DCHECK(false)
<< "Should not be called since release time is unsupported.";
return ReleaseTime{0, QuicTime::Delta::Zero()};
@@ -101,6 +102,7 @@
const QuicIpAddress& self_address,
const QuicSocketAddress& peer_address,
const PerPacketOptions* options,
+ const QuicPacketWriterParams& params,
uint64_t release_time) const = 0;
struct QUIC_EXPORT_PRIVATE FlushImplResult {
@@ -129,7 +131,8 @@
WriteResult InternalWritePacket(const char* buffer, size_t buf_len,
const QuicIpAddress& self_address,
const QuicSocketAddress& peer_address,
- PerPacketOptions* options);
+ PerPacketOptions* options,
+ const QuicPacketWriterParams& params);
// Calls FlushImpl() and check its post condition.
FlushImplResult CheckedFlush();
diff --git a/quiche/quic/core/batch_writer/quic_batch_writer_buffer.cc b/quiche/quic/core/batch_writer/quic_batch_writer_buffer.cc
index ac7ddd7..d283e2b 100644
--- a/quiche/quic/core/batch_writer/quic_batch_writer_buffer.cc
+++ b/quiche/quic/core/batch_writer/quic_batch_writer_buffer.cc
@@ -54,7 +54,7 @@
QuicBatchWriterBuffer::PushResult QuicBatchWriterBuffer::PushBufferedWrite(
const char* buffer, size_t buf_len, const QuicIpAddress& self_address,
const QuicSocketAddress& peer_address, const PerPacketOptions* options,
- uint64_t release_time) {
+ const QuicPacketWriterParams& params, uint64_t release_time) {
QUICHE_DCHECK(Invariants());
QUICHE_DCHECK_LE(buf_len, kMaxOutgoingPacketSize);
@@ -84,7 +84,7 @@
}
buffered_writes_.emplace_back(
next_write_location, buf_len, self_address, peer_address,
- options ? options->Clone() : std::unique_ptr<PerPacketOptions>(),
+ options ? options->Clone() : std::unique_ptr<PerPacketOptions>(), params,
release_time);
QUICHE_DCHECK(Invariants());
diff --git a/quiche/quic/core/batch_writer/quic_batch_writer_buffer.h b/quiche/quic/core/batch_writer/quic_batch_writer_buffer.h
index 2369401..62282a3 100644
--- a/quiche/quic/core/batch_writer/quic_batch_writer_buffer.h
+++ b/quiche/quic/core/batch_writer/quic_batch_writer_buffer.h
@@ -44,6 +44,7 @@
const QuicIpAddress& self_address,
const QuicSocketAddress& peer_address,
const PerPacketOptions* options,
+ const QuicPacketWriterParams& params,
uint64_t release_time);
void UndoLastPush();
diff --git a/quiche/quic/core/batch_writer/quic_batch_writer_buffer_test.cc b/quiche/quic/core/batch_writer/quic_batch_writer_buffer_test.cc
index e081a79..ffa88f0 100644
--- a/quiche/quic/core/batch_writer/quic_batch_writer_buffer_test.cc
+++ b/quiche/quic/core/batch_writer/quic_batch_writer_buffer_test.cc
@@ -52,7 +52,8 @@
void CheckBufferedWriteContent(int buffered_write_index, char buffer_content,
size_t buf_len, const QuicIpAddress& self_addr,
const QuicSocketAddress& peer_addr,
- const PerPacketOptions* options) {
+ const PerPacketOptions* /*options*/,
+ const QuicPacketWriterParams& params) {
const BufferedWrite& buffered_write =
batch_buffer_->buffered_writes()[buffered_write_index];
EXPECT_EQ(buf_len, buffered_write.buf_len);
@@ -64,12 +65,8 @@
}
EXPECT_EQ(self_addr, buffered_write.self_address);
EXPECT_EQ(peer_addr, buffered_write.peer_address);
- if (options == nullptr) {
- EXPECT_EQ(nullptr, buffered_write.options);
- } else {
- EXPECT_EQ(options->release_time_delay,
- buffered_write.options->release_time_delay);
- }
+ EXPECT_EQ(params.release_time_delay,
+ buffered_write.params.release_time_delay);
}
protected:
@@ -141,7 +138,8 @@
<< ", batch_buffer=" << batch_buffer_->DebugString());
auto push_result = batch_buffer_->PushBufferedWrite(
- buffer, buf_len, self_addr_, peer_addr_, nullptr, release_time_);
+ buffer, buf_len, self_addr_, peer_addr_, nullptr,
+ QuicPacketWriterParams(), release_time_);
if (!push_result.succeeded) {
++num_push_failures;
}
@@ -160,49 +158,51 @@
TEST_F(QuicBatchWriterBufferTest, MixedPushes) {
// First, a in-place push.
char* buffer = batch_buffer_->GetNextWriteLocation();
+ QuicPacketWriterParams params;
auto push_result = batch_buffer_->PushBufferedWrite(
FillPacketBuffer('A', buffer), kDefaultMaxPacketSize, self_addr_,
- peer_addr_, nullptr, release_time_);
+ peer_addr_, nullptr, params, release_time_);
EXPECT_TRUE(push_result.succeeded);
EXPECT_FALSE(push_result.buffer_copied);
CheckBufferedWriteContent(0, 'A', kDefaultMaxPacketSize, self_addr_,
- peer_addr_, nullptr);
+ peer_addr_, nullptr, params);
// Then a push with external buffer.
push_result = batch_buffer_->PushBufferedWrite(
FillPacketBuffer('B'), kDefaultMaxPacketSize, self_addr_, peer_addr_,
- nullptr, release_time_);
+ nullptr, params, release_time_);
EXPECT_TRUE(push_result.succeeded);
EXPECT_TRUE(push_result.buffer_copied);
CheckBufferedWriteContent(1, 'B', kDefaultMaxPacketSize, self_addr_,
- peer_addr_, nullptr);
+ peer_addr_, nullptr, params);
// Then another in-place push.
buffer = batch_buffer_->GetNextWriteLocation();
push_result = batch_buffer_->PushBufferedWrite(
FillPacketBuffer('C', buffer), kDefaultMaxPacketSize, self_addr_,
- peer_addr_, nullptr, release_time_);
+ peer_addr_, nullptr, params, release_time_);
EXPECT_TRUE(push_result.succeeded);
EXPECT_FALSE(push_result.buffer_copied);
CheckBufferedWriteContent(2, 'C', kDefaultMaxPacketSize, self_addr_,
- peer_addr_, nullptr);
+ peer_addr_, nullptr, params);
// Then another push with external buffer.
push_result = batch_buffer_->PushBufferedWrite(
FillPacketBuffer('D'), kDefaultMaxPacketSize, self_addr_, peer_addr_,
- nullptr, release_time_);
+ nullptr, params, release_time_);
EXPECT_TRUE(push_result.succeeded);
EXPECT_TRUE(push_result.buffer_copied);
CheckBufferedWriteContent(3, 'D', kDefaultMaxPacketSize, self_addr_,
- peer_addr_, nullptr);
+ peer_addr_, nullptr, params);
}
TEST_F(QuicBatchWriterBufferTest, PopAll) {
const int kNumBufferedWrites = 10;
+ QuicPacketWriterParams params;
for (int i = 0; i < kNumBufferedWrites; ++i) {
EXPECT_TRUE(batch_buffer_
->PushBufferedWrite(packet_buffer_, kDefaultMaxPacketSize,
- self_addr_, peer_addr_, nullptr,
+ self_addr_, peer_addr_, nullptr, params,
release_time_)
.succeeded);
}
@@ -217,11 +217,12 @@
TEST_F(QuicBatchWriterBufferTest, PopPartial) {
const int kNumBufferedWrites = 10;
+ QuicPacketWriterParams params;
for (int i = 0; i < kNumBufferedWrites; ++i) {
EXPECT_TRUE(batch_buffer_
- ->PushBufferedWrite(FillPacketBuffer('A' + i),
- kDefaultMaxPacketSize - i, self_addr_,
- peer_addr_, nullptr, release_time_)
+ ->PushBufferedWrite(
+ FillPacketBuffer('A' + i), kDefaultMaxPacketSize - i,
+ self_addr_, peer_addr_, nullptr, params, release_time_)
.succeeded);
}
@@ -239,7 +240,7 @@
kDefaultMaxPacketSize - kNumBufferedWrites + expect_size_after_pop;
for (size_t j = 0; j < expect_size_after_pop; ++j) {
CheckBufferedWriteContent(j, first_write_content + j, first_write_len - j,
- self_addr_, peer_addr_, nullptr);
+ self_addr_, peer_addr_, nullptr, params);
}
}
}
@@ -248,13 +249,14 @@
// First, a in-place push.
char* buffer = batch_buffer_->GetNextWriteLocation();
const size_t first_packet_len = 2;
+ QuicPacketWriterParams params;
auto push_result = batch_buffer_->PushBufferedWrite(
FillPacketBuffer('A', buffer, first_packet_len), first_packet_len,
- self_addr_, peer_addr_, nullptr, release_time_);
+ self_addr_, peer_addr_, nullptr, params, release_time_);
EXPECT_TRUE(push_result.succeeded);
EXPECT_FALSE(push_result.buffer_copied);
CheckBufferedWriteContent(0, 'A', first_packet_len, self_addr_, peer_addr_,
- nullptr);
+ nullptr, params);
// Simulate the case where the writer wants to do another in-place push, but
// can't do so because it can't be batched with the first buffer.
@@ -269,11 +271,11 @@
// Now the second push.
push_result = batch_buffer_->PushBufferedWrite(
FillPacketBuffer('B', buffer, second_packet_len), second_packet_len,
- self_addr_, peer_addr_, nullptr, release_time_);
+ self_addr_, peer_addr_, nullptr, params, release_time_);
EXPECT_TRUE(push_result.succeeded);
EXPECT_TRUE(push_result.buffer_copied);
CheckBufferedWriteContent(0, 'B', second_packet_len, self_addr_, peer_addr_,
- nullptr);
+ nullptr, params);
}
} // namespace
diff --git a/quiche/quic/core/batch_writer/quic_batch_writer_test.h b/quiche/quic/core/batch_writer/quic_batch_writer_test.h
index ebbb917..d42867f 100644
--- a/quiche/quic/core/batch_writer/quic_batch_writer_test.h
+++ b/quiche/quic/core/batch_writer/quic_batch_writer_test.h
@@ -195,7 +195,7 @@
result = GetWriter()->WritePacket(&packet_buffer_[0], this_packet_size,
self_address_.host(), peer_address_,
- nullptr);
+ nullptr, QuicPacketWriterParams());
ASSERT_EQ(WRITE_STATUS_OK, result.status) << strerror(result.error_code);
bytes_flushed += result.bytes_written;
diff --git a/quiche/quic/core/batch_writer/quic_gso_batch_writer.cc b/quiche/quic/core/batch_writer/quic_gso_batch_writer.cc
index b6d6200..512e51f 100644
--- a/quiche/quic/core/batch_writer/quic_gso_batch_writer.cc
+++ b/quiche/quic/core/batch_writer/quic_gso_batch_writer.cc
@@ -49,8 +49,8 @@
QuicGsoBatchWriter::CanBatchResult QuicGsoBatchWriter::CanBatch(
const char* /*buffer*/, size_t buf_len, const QuicIpAddress& self_address,
- const QuicSocketAddress& peer_address, const PerPacketOptions* options,
- uint64_t release_time) const {
+ const QuicSocketAddress& peer_address, const PerPacketOptions* /*options*/,
+ const QuicPacketWriterParams& params, uint64_t release_time) const {
// If there is nothing buffered already, this write will be included in this
// batch.
if (buffered_writes().empty()) {
@@ -70,9 +70,9 @@
const BufferedWrite& first = buffered_writes().front();
const BufferedWrite& last = buffered_writes().back();
// Whether this packet can be sent without delay, regardless of release time.
- const bool can_burst = !SupportsReleaseTime() || !options ||
- options->release_time_delay.IsZero() ||
- options->allow_burst;
+ const bool can_burst = !SupportsReleaseTime() ||
+ params.release_time_delay.IsZero() ||
+ params.allow_burst;
size_t max_segments = MaxSegments(first.buf_len);
bool can_batch =
buffered_writes().size() < max_segments && // [0]
@@ -96,18 +96,14 @@
}
QuicGsoBatchWriter::ReleaseTime QuicGsoBatchWriter::GetReleaseTime(
- const PerPacketOptions* options) const {
+ const QuicPacketWriterParams& params) const {
QUICHE_DCHECK(SupportsReleaseTime());
- if (options == nullptr) {
- return {0, QuicTime::Delta::Zero()};
- }
-
const uint64_t now = NowInNanosForReleaseTime();
const uint64_t ideal_release_time =
- now + options->release_time_delay.ToMicroseconds() * 1000;
+ now + params.release_time_delay.ToMicroseconds() * 1000;
- if ((options->release_time_delay.IsZero() || options->allow_burst) &&
+ if ((params.release_time_delay.IsZero() || params.allow_burst) &&
!buffered_writes().empty() &&
// If release time of buffered packets is in the past, flush buffered
// packets and buffer this packet at the ideal release time.
diff --git a/quiche/quic/core/batch_writer/quic_gso_batch_writer.h b/quiche/quic/core/batch_writer/quic_gso_batch_writer.h
index 17657fc..96ccc76 100644
--- a/quiche/quic/core/batch_writer/quic_gso_batch_writer.h
+++ b/quiche/quic/core/batch_writer/quic_gso_batch_writer.h
@@ -25,6 +25,7 @@
const QuicIpAddress& self_address,
const QuicSocketAddress& peer_address,
const PerPacketOptions* options,
+ const QuicPacketWriterParams& params,
uint64_t release_time) const override;
FlushImplResult FlushImpl() override;
@@ -36,7 +37,8 @@
int fd, clockid_t clockid_for_release_time,
ReleaseTimeForceEnabler enabler);
- ReleaseTime GetReleaseTime(const PerPacketOptions* options) const override;
+ ReleaseTime GetReleaseTime(
+ const QuicPacketWriterParams& params) const override;
// Get the current time in nanos from |clockid_for_release_time_|.
virtual uint64_t NowInNanosForReleaseTime() const;
diff --git a/quiche/quic/core/batch_writer/quic_gso_batch_writer_test.cc b/quiche/quic/core/batch_writer/quic_gso_batch_writer_test.cc
index efe4c71..c4c0406 100644
--- a/quiche/quic/core/batch_writer/quic_gso_batch_writer_test.cc
+++ b/quiche/quic/core/batch_writer/quic_gso_batch_writer_test.cc
@@ -75,7 +75,7 @@
other.peer_address,
other.options ? other.options->Clone()
: std::unique_ptr<PerPacketOptions>(),
- other.release_time) {}
+ QuicPacketWriterParams(), other.release_time) {}
};
// Pointed to by all instances of |BatchCriteriaTestData|. Content not used.
@@ -87,7 +87,7 @@
uint64_t release_time, bool can_batch, bool must_flush)
: buffered_write(unused_packet_buffer, buf_len, self_address,
peer_address, std::unique_ptr<PerPacketOptions>(),
- release_time),
+ QuicPacketWriterParams(), release_time),
can_batch(can_batch),
must_flush(must_flush) {}
@@ -203,13 +203,14 @@
protected:
WriteResult WritePacket(QuicGsoBatchWriter* writer, size_t packet_size) {
return writer->WritePacket(&packet_buffer_[0], packet_size, self_address_,
- peer_address_, nullptr);
+ peer_address_, nullptr,
+ QuicPacketWriterParams());
}
- WriteResult WritePacketWithOptions(QuicGsoBatchWriter* writer,
- PerPacketOptions* options) {
+ WriteResult WritePacketWithParams(QuicGsoBatchWriter* writer,
+ QuicPacketWriterParams& params) {
return writer->WritePacket(&packet_buffer_[0], 1350, self_address_,
- peer_address_, options);
+ peer_address_, nullptr, params);
}
QuicIpAddress self_address_ = QuicIpAddress::Any4();
@@ -239,13 +240,13 @@
for (size_t j = 0; j < test_data_table.size(); ++j) {
const BatchCriteriaTestData& test_data = test_data_table[j];
SCOPED_TRACE(testing::Message() << "i=" << i << ", j=" << j);
- TestPerPacketOptions options;
- options.release_time_delay = QuicTime::Delta::FromMicroseconds(
+ QuicPacketWriterParams params;
+ params.release_time_delay = QuicTime::Delta::FromMicroseconds(
test_data.buffered_write.release_time);
TestQuicGsoBatchWriter::CanBatchResult result = writer->CanBatch(
test_data.buffered_write.buffer, test_data.buffered_write.buf_len,
test_data.buffered_write.self_address,
- test_data.buffered_write.peer_address, &options,
+ test_data.buffered_write.peer_address, nullptr, params,
test_data.buffered_write.release_time);
ASSERT_EQ(test_data.can_batch, result.can_batch);
@@ -257,8 +258,8 @@
test_data.buffered_write.buffer,
test_data.buffered_write.buf_len,
test_data.buffered_write.self_address,
- test_data.buffered_write.peer_address, &options,
- test_data.buffered_write.release_time)
+ test_data.buffered_write.peer_address, nullptr,
+ params, test_data.buffered_write.release_time)
.succeeded);
}
}
@@ -379,32 +380,27 @@
ASSERT_EQ(0u, writer.buffered_writes().size());
}
-TEST_F(QuicGsoBatchWriterTest, ReleaseTimeNullOptions) {
- auto writer = TestQuicGsoBatchWriter::NewInstanceWithReleaseTimeSupport();
- EXPECT_EQ(0u, writer->GetReleaseTime(nullptr).actual_release_time);
-}
-
TEST_F(QuicGsoBatchWriterTest, ReleaseTime) {
const WriteResult write_buffered(WRITE_STATUS_OK, 0);
auto writer = TestQuicGsoBatchWriter::NewInstanceWithReleaseTimeSupport();
- TestPerPacketOptions options;
- EXPECT_TRUE(options.release_time_delay.IsZero());
- EXPECT_FALSE(options.allow_burst);
+ QuicPacketWriterParams params;
+ EXPECT_TRUE(params.release_time_delay.IsZero());
+ EXPECT_FALSE(params.allow_burst);
EXPECT_EQ(MillisToNanos(1),
- writer->GetReleaseTime(&options).actual_release_time);
+ writer->GetReleaseTime(params).actual_release_time);
// The 1st packet has no delay.
- WriteResult result = WritePacketWithOptions(writer.get(), &options);
+ WriteResult result = WritePacketWithParams(writer.get(), params);
ASSERT_EQ(write_buffered, result);
EXPECT_EQ(MillisToNanos(1), writer->buffered_writes().back().release_time);
EXPECT_EQ(result.send_time_offset, QuicTime::Delta::Zero());
// The 2nd packet has some delay, but allows burst.
- options.release_time_delay = QuicTime::Delta::FromMilliseconds(3);
- options.allow_burst = true;
- result = WritePacketWithOptions(writer.get(), &options);
+ params.release_time_delay = QuicTime::Delta::FromMilliseconds(3);
+ params.allow_burst = true;
+ result = WritePacketWithParams(writer.get(), params);
ASSERT_EQ(write_buffered, result);
EXPECT_EQ(MillisToNanos(1), writer->buffered_writes().back().release_time);
EXPECT_EQ(result.send_time_offset, QuicTime::Delta::FromMilliseconds(-3));
@@ -417,16 +413,16 @@
errno = 0;
return 0;
}));
- options.release_time_delay = QuicTime::Delta::FromMilliseconds(5);
- options.allow_burst = false;
- result = WritePacketWithOptions(writer.get(), &options);
+ params.release_time_delay = QuicTime::Delta::FromMilliseconds(5);
+ params.allow_burst = false;
+ result = WritePacketWithParams(writer.get(), params);
ASSERT_EQ(WriteResult(WRITE_STATUS_OK, 2700), result);
EXPECT_EQ(MillisToNanos(6), writer->buffered_writes().back().release_time);
EXPECT_EQ(result.send_time_offset, QuicTime::Delta::Zero());
// The 4th packet has same delay, but allows burst.
- options.allow_burst = true;
- result = WritePacketWithOptions(writer.get(), &options);
+ params.allow_burst = true;
+ result = WritePacketWithParams(writer.get(), params);
ASSERT_EQ(write_buffered, result);
EXPECT_EQ(MillisToNanos(6), writer->buffered_writes().back().release_time);
EXPECT_EQ(result.send_time_offset, QuicTime::Delta::Zero());
@@ -439,19 +435,19 @@
errno = 0;
return 0;
}));
- options.allow_burst = true;
+ params.allow_burst = true;
EXPECT_EQ(MillisToNanos(6),
- writer->GetReleaseTime(&options).actual_release_time);
+ writer->GetReleaseTime(params).actual_release_time);
ASSERT_EQ(WriteResult(WRITE_STATUS_OK, 3000),
writer->WritePacket(&packet_buffer_[0], 300, self_address_,
- peer_address_, &options));
+ peer_address_, nullptr, params));
EXPECT_TRUE(writer->buffered_writes().empty());
// Pretend 1ms has elapsed and the 6th packet has 1ms less delay. In other
// words, the release time should still be the same as packets 3-5.
writer->ForceReleaseTimeMs(2);
- options.release_time_delay = QuicTime::Delta::FromMilliseconds(4);
- result = WritePacketWithOptions(writer.get(), &options);
+ params.release_time_delay = QuicTime::Delta::FromMilliseconds(4);
+ result = WritePacketWithParams(writer.get(), params);
ASSERT_EQ(write_buffered, result);
EXPECT_EQ(MillisToNanos(6), writer->buffered_writes().back().release_time);
EXPECT_EQ(result.send_time_offset, QuicTime::Delta::Zero());
diff --git a/quiche/quic/core/batch_writer/quic_sendmmsg_batch_writer.cc b/quiche/quic/core/batch_writer/quic_sendmmsg_batch_writer.cc
index 8568e26..0c724b2 100644
--- a/quiche/quic/core/batch_writer/quic_sendmmsg_batch_writer.cc
+++ b/quiche/quic/core/batch_writer/quic_sendmmsg_batch_writer.cc
@@ -14,7 +14,8 @@
const char* /*buffer*/, size_t /*buf_len*/,
const QuicIpAddress& /*self_address*/,
const QuicSocketAddress& /*peer_address*/,
- const PerPacketOptions* /*options*/, uint64_t /*release_time*/) const {
+ const PerPacketOptions* /*options*/,
+ const QuicPacketWriterParams& /*params*/, uint64_t /*release_time*/) const {
return CanBatchResult(/*can_batch=*/true, /*must_flush=*/false);
}
diff --git a/quiche/quic/core/batch_writer/quic_sendmmsg_batch_writer.h b/quiche/quic/core/batch_writer/quic_sendmmsg_batch_writer.h
index 04a1b28..9dda5dd 100644
--- a/quiche/quic/core/batch_writer/quic_sendmmsg_batch_writer.h
+++ b/quiche/quic/core/batch_writer/quic_sendmmsg_batch_writer.h
@@ -19,6 +19,7 @@
const QuicIpAddress& self_address,
const QuicSocketAddress& peer_address,
const PerPacketOptions* options,
+ const QuicPacketWriterParams& params,
uint64_t release_time) const override;
FlushImplResult FlushImpl() override;
diff --git a/quiche/quic/core/http/end_to_end_test.cc b/quiche/quic/core/http/end_to_end_test.cc
index 44e3abe..d4e442f 100644
--- a/quiche/quic/core/http/end_to_end_test.cc
+++ b/quiche/quic/core/http/end_to_end_test.cc
@@ -31,6 +31,7 @@
#include "quiche/quic/core/quic_error_codes.h"
#include "quiche/quic/core/quic_framer.h"
#include "quiche/quic/core/quic_packet_creator.h"
+#include "quiche/quic/core/quic_packet_writer.h"
#include "quiche/quic/core/quic_packet_writer_wrapper.h"
#include "quiche/quic/core/quic_packets.h"
#include "quiche/quic/core/quic_session.h"
@@ -947,6 +948,7 @@
std::vector<std::string> received_webtransport_unidirectional_streams_;
bool use_preferred_address_ = false;
QuicSocketAddress server_preferred_address_;
+ QuicPacketWriterParams packet_writer_params_;
};
// Run all end to end tests with all supported versions.
@@ -3206,15 +3208,17 @@
WriteResult WritePacket(const char* buffer, size_t buf_len,
const QuicIpAddress& self_address,
const QuicSocketAddress& peer_address,
- PerPacketOptions* options) override {
+ PerPacketOptions* options,
+ const QuicPacketWriterParams& params) override {
if (self_address_to_overwrite_.IsInitialized()) {
// Send the same packet on the overwriting address before sending on the
// actual self address.
- QuicPacketWriterWrapper::WritePacket(
- buffer, buf_len, self_address_to_overwrite_, peer_address, options);
+ QuicPacketWriterWrapper::WritePacket(buffer, buf_len,
+ self_address_to_overwrite_,
+ peer_address, options, params);
}
return QuicPacketWriterWrapper::WritePacket(buffer, buf_len, self_address,
- peer_address, options);
+ peer_address, options, params);
}
void set_self_address_to_overwrite(const QuicIpAddress& self_address) {
@@ -3996,7 +4000,8 @@
server_thread_->Pause();
auto client_address = client_connection->self_address();
server_writer_->WritePacket(packet->data(), packet->length(),
- server_address_.host(), client_address, nullptr);
+ server_address_.host(), client_address, nullptr,
+ packet_writer_params_);
server_thread_->Resume();
// The request should fail.
@@ -4038,7 +4043,8 @@
server_thread_->Pause();
auto client_address = client_connection->self_address();
server_writer_->WritePacket(packet->data(), packet->length(),
- server_address_.host(), client_address, nullptr);
+ server_address_.host(), client_address, nullptr,
+ packet_writer_params_);
server_thread_->Resume();
// The request should fail. IETF stateless reset does not include connection
@@ -4087,7 +4093,7 @@
client_writer_->WritePacket(
packet->data(), packet->length(),
client_->client()->network_helper()->GetLatestClientAddress().host(),
- server_address_, nullptr);
+ server_address_, nullptr, packet_writer_params_);
// The connection should be unaffected.
SendSynchronousFooRequestAndCheckResponse();
@@ -4119,7 +4125,8 @@
server_thread_->Pause();
server_writer_->WritePacket(
packet->data(), packet->length(), server_address_.host(),
- client_->client()->network_helper()->GetLatestClientAddress(), nullptr);
+ client_->client()->network_helper()->GetLatestClientAddress(), nullptr,
+ packet_writer_params_);
server_thread_->Resume();
// The connection should be unaffected.
@@ -4149,10 +4156,11 @@
WriteResult WritePacket(const char* buffer, size_t buf_len,
const QuicIpAddress& self_address,
const QuicSocketAddress& peer_address,
- quic::PerPacketOptions* options) override {
+ quic::PerPacketOptions* options,
+ const quic::QuicPacketWriterParams& params) override {
if (!intercept_enabled_) {
return PacketDroppingTestWriter::WritePacket(
- buffer, buf_len, self_address, peer_address, options);
+ buffer, buf_len, self_address, peer_address, options, params);
}
PacketHeaderFormat format;
QuicLongHeaderType long_packet_type;
@@ -4177,16 +4185,19 @@
intercept_enabled_ = false;
server_thread_->Resume();
// Pass the client-sent packet through.
- return WritePacket(buffer, buf_len, self_address, peer_address, options);
+ return WritePacket(buffer, buf_len, self_address, peer_address, options,
+ params);
}
// Send a version negotiation packet.
std::unique_ptr<QuicEncryptedPacket> packet(
QuicFramer::BuildVersionNegotiationPacket(
destination_connection_id, source_connection_id, /*ietf_quic=*/true,
has_length_prefix, supported_versions_));
+ QuicPacketWriterParams default_params;
server_writer_->WritePacket(
packet->data(), packet->length(), peer_address.host(),
- client_->client()->network_helper()->GetLatestClientAddress(), nullptr);
+ client_->client()->network_helper()->GetLatestClientAddress(), nullptr,
+ default_params);
// Drop the client-sent packet but pretend it was sent.
return WriteResult(WRITE_STATUS_OK, buf_len);
}
@@ -4248,7 +4259,7 @@
client_writer_->WritePacket(
&packet[0], sizeof(packet),
client_->client()->network_helper()->GetLatestClientAddress().host(),
- server_address_, nullptr);
+ server_address_, nullptr, packet_writer_params_);
EXPECT_TRUE(server_thread_->WaitUntil(
[&] {
return QuicDispatcherPeer::GetAndClearLastError(
@@ -4295,7 +4306,7 @@
client_writer_->WritePacket(
reinterpret_cast<const char*>(packet), sizeof(packet),
client_->client()->network_helper()->GetLatestClientAddress().host(),
- server_address_, nullptr);
+ server_address_, nullptr, packet_writer_params_);
EXPECT_TRUE(server_thread_->WaitUntil(
[&] {
@@ -4331,7 +4342,7 @@
client_writer_->WritePacket(
damaged_packet.data(), damaged_packet.length(),
client_->client()->network_helper()->GetLatestClientAddress().host(),
- server_address_, nullptr);
+ server_address_, nullptr, packet_writer_params_);
// Give the server time to process the packet.
absl::SleepFor(absl::Seconds(1));
// This error is sent to the connection's OnError (which ignores it), so the
@@ -5261,10 +5272,11 @@
WriteResult WritePacket(const char* buffer, size_t buf_len,
const QuicIpAddress& self_address,
const QuicSocketAddress& peer_address,
- PerPacketOptions* options) override {
+ PerPacketOptions* options,
+ const QuicPacketWriterParams& params) override {
if (!hold_next_packet_) {
- return QuicPacketWriterWrapper::WritePacket(buffer, buf_len, self_address,
- peer_address, options);
+ return QuicPacketWriterWrapper::WritePacket(
+ buffer, buf_len, self_address, peer_address, options, params);
}
QUIC_DLOG(INFO) << "Packet is held by the writer";
packet_content_ = std::string(buffer, buf_len);
@@ -5286,7 +5298,7 @@
ASSERT_EQ(WRITE_STATUS_OK,
QuicPacketWriterWrapper::WritePacket(
packet_content_.data(), packet_content_.length(),
- self_address_, peer_address_, options_.release())
+ self_address_, peer_address_, options_.release(), params_)
.status);
packet_content_.clear();
}
@@ -5297,6 +5309,7 @@
QuicIpAddress self_address_;
QuicSocketAddress peer_address_;
std::unique_ptr<PerPacketOptions> options_;
+ QuicPacketWriterParams params_;
};
TEST_P(EndToEndTest, ClientValidateNewNetwork) {
@@ -5849,9 +5862,10 @@
WriteResult WritePacket(const char* buffer, size_t buf_len,
const QuicIpAddress& self_address,
const QuicSocketAddress& peer_address,
- quic::PerPacketOptions* options) override {
+ quic::PerPacketOptions* options,
+ const quic::QuicPacketWriterParams& params) override {
const WriteResult result = QuicPacketWriterWrapper::WritePacket(
- buffer, buf_len, self_address, peer_address, options);
+ buffer, buf_len, self_address, peer_address, options, params);
const uint8_t type_byte = buffer[0];
if (!error_returned_ && (type_byte & FLAGS_LONG_HEADER) &&
TypeByteIsServerHello(type_byte)) {
@@ -5924,7 +5938,8 @@
WriteResult WritePacket(const char* buffer, size_t buf_len,
const QuicIpAddress& self_address,
const QuicSocketAddress& peer_address,
- quic::PerPacketOptions* options) override {
+ quic::PerPacketOptions* options,
+ const quic::QuicPacketWriterParams& params) override {
const uint8_t type_byte = buffer[0];
if (type_byte & FLAGS_LONG_HEADER) {
@@ -5939,7 +5954,7 @@
return WriteResult(WRITE_STATUS_ERROR, *MessageTooBigErrorCode());
}
return QuicPacketWriterWrapper::WritePacket(buffer, buf_len, self_address,
- peer_address, options);
+ peer_address, options, params);
}
private:
@@ -6076,14 +6091,15 @@
WriteResult WritePacket(const char* buffer, size_t buf_len,
const QuicIpAddress& self_address,
const QuicSocketAddress& peer_address,
- PerPacketOptions* options) override {
+ PerPacketOptions* options,
+ const QuicPacketWriterParams& params) override {
if (num_packets_to_copy_ > 0) {
num_packets_to_copy_--;
packets_.push_back(
QuicEncryptedPacket(buffer, buf_len, /*owns_buffer=*/false).Clone());
}
return PacketDroppingTestWriter::WritePacket(buffer, buf_len, self_address,
- peer_address, options);
+ peer_address, options, params);
}
std::vector<std::unique_ptr<QuicEncryptedPacket>>& packets() {
@@ -7097,9 +7113,7 @@
EXPECT_EQ(ecn->ect0, 0);
EXPECT_EQ(ecn->ect1, 0);
EXPECT_EQ(ecn->ce, 0);
- TestPerPacketOptions options;
- client_connection->set_per_packet_options(&options);
- options.ecn_codepoint = ECN_NOT_ECT;
+ client_connection->set_ecn_codepoint(ECN_NOT_ECT);
client_->SendSynchronousRequest("/foo");
EXPECT_EQ(ecn->ect0, 0);
EXPECT_EQ(ecn->ect1, 0);
@@ -7119,9 +7133,7 @@
EXPECT_EQ(ecn->ect0, 0);
EXPECT_EQ(ecn->ect1, 0);
EXPECT_EQ(ecn->ce, 0);
- TestPerPacketOptions options;
- client_connection->set_per_packet_options(&options);
- options.ecn_codepoint = ECN_ECT0;
+ client_connection->set_ecn_codepoint(ECN_ECT0);
client_->SendSynchronousRequest("/foo");
if (!GetQuicRestartFlag(quic_receive_ecn) ||
!GetQuicRestartFlag(quic_quiche_ecn_sockets) ||
@@ -7147,9 +7159,7 @@
EXPECT_EQ(ecn->ect0, 0);
EXPECT_EQ(ecn->ect1, 0);
EXPECT_EQ(ecn->ce, 0);
- TestPerPacketOptions options;
- client_connection->set_per_packet_options(&options);
- options.ecn_codepoint = ECN_ECT1;
+ client_connection->set_ecn_codepoint(ECN_ECT1);
client_->SendSynchronousRequest("/foo");
if (!GetQuicRestartFlag(quic_receive_ecn) ||
!GetQuicRestartFlag(quic_quiche_ecn_sockets) ||
@@ -7175,9 +7185,7 @@
EXPECT_EQ(ecn->ect0, 0);
EXPECT_EQ(ecn->ect1, 0);
EXPECT_EQ(ecn->ce, 0);
- TestPerPacketOptions options;
- client_connection->set_per_packet_options(&options);
- options.ecn_codepoint = ECN_CE;
+ client_connection->set_ecn_codepoint(ECN_CE);
client_->SendSynchronousRequest("/foo");
if (!GetQuicRestartFlag(quic_receive_ecn) ||
!GetQuicRestartFlag(quic_quiche_ecn_sockets) ||
@@ -7202,9 +7210,7 @@
QuicEcnCounts* ecn = QuicSentPacketManagerPeer::GetPeerEcnCounts(
QuicConnectionPeer::GetSentPacketManager(server_connection),
APPLICATION_DATA);
- TestPerPacketOptions options;
- options.ecn_codepoint = ECN_ECT1;
- server_connection->set_per_packet_options(&options);
+ server_connection->set_ecn_codepoint(ECN_ECT1);
client_->SendSynchronousRequest("/foo");
// A second request provides a packet for the client ACKs to go with.
client_->SendSynchronousRequest("/foo");
diff --git a/quiche/quic/core/http/quic_spdy_session_test.cc b/quiche/quic/core/http/quic_spdy_session_test.cc
index e778864..6c98257 100644
--- a/quiche/quic/core/http/quic_spdy_session_test.cc
+++ b/quiche/quic/core/http/quic_spdy_session_test.cc
@@ -523,7 +523,7 @@
void CompleteHandshake() {
if (VersionHasIetfQuicFrames(transport_version())) {
- EXPECT_CALL(*writer_, WritePacket(_, _, _, _, _))
+ EXPECT_CALL(*writer_, WritePacket(_, _, _, _, _, _))
.WillOnce(Return(WriteResult(WRITE_STATUS_OK, 0)));
}
if (connection_->version().UsesTls() &&
@@ -791,7 +791,7 @@
TEST_P(QuicSpdySessionTestServer,
DebugDFatalIfMarkingClosedStreamWriteBlocked) {
CompleteHandshake();
- EXPECT_CALL(*writer_, WritePacket(_, _, _, _, _))
+ EXPECT_CALL(*writer_, WritePacket(_, _, _, _, _, _))
.WillRepeatedly(Return(WriteResult(WRITE_STATUS_OK, 0)));
TestStream* stream2 = session_.CreateOutgoingBidirectionalStream();
@@ -822,7 +822,7 @@
static_cast<QuicSession*>(&session_), QuicUtils::GetMaxStreamCount());
QuicStreamsBlockedFrame frame;
frame.stream_count = QuicUtils::GetMaxStreamCount();
- EXPECT_CALL(*writer_, WritePacket(_, _, _, _, _))
+ EXPECT_CALL(*writer_, WritePacket(_, _, _, _, _, _))
.WillOnce(Return(WriteResult(WRITE_STATUS_OK, 0)));
EXPECT_CALL(debug_visitor, OnGoAwayFrameSent(_));
session_.OnStreamsBlockedFrame(frame);
@@ -860,7 +860,7 @@
// Expect that we only send one packet, the writes from different streams
// should be bundled together.
- EXPECT_CALL(*writer_, WritePacket(_, _, _, _, _))
+ EXPECT_CALL(*writer_, WritePacket(_, _, _, _, _, _))
.WillOnce(Return(WriteResult(WRITE_STATUS_OK, 0)));
EXPECT_CALL(*send_algorithm, OnPacketSent(_, _, _, _, _));
EXPECT_CALL(*send_algorithm, OnApplicationLimited(_));
@@ -926,7 +926,7 @@
// Drive packet writer manually.
EXPECT_CALL(*writer_, IsWriteBlocked()).WillRepeatedly(Return(true));
- EXPECT_CALL(*writer_, WritePacket(_, _, _, _, _)).Times(0);
+ EXPECT_CALL(*writer_, WritePacket(_, _, _, _, _, _)).Times(0);
TestStream* stream2 = session_.CreateOutgoingBidirectionalStream();
@@ -1078,7 +1078,7 @@
return;
}
connection_->SetDefaultEncryptionLevel(ENCRYPTION_FORWARD_SECURE);
- EXPECT_CALL(*writer_, WritePacket(_, _, _, _, _))
+ EXPECT_CALL(*writer_, WritePacket(_, _, _, _, _, _))
.WillOnce(Return(WriteResult(WRITE_STATUS_OK, 0)));
EXPECT_CALL(*connection_, SendControlFrame(_))
@@ -1118,7 +1118,7 @@
StrictMock<MockHttp3DebugVisitor> debug_visitor;
session_.set_debug_visitor(&debug_visitor);
- EXPECT_CALL(*writer_, WritePacket(_, _, _, _, _))
+ EXPECT_CALL(*writer_, WritePacket(_, _, _, _, _, _))
.WillOnce(Return(WriteResult(WRITE_STATUS_OK, 0)));
// Send max stream id (currently 32 bits).
EXPECT_CALL(debug_visitor, OnGoAwayFrameSent(/* stream_id = */ 0xfffffffc));
@@ -1161,7 +1161,7 @@
GetNthClientInitiatedBidirectionalStreamId(transport_version(), 0);
EXPECT_TRUE(session_.GetOrCreateStream(kTestStreamId));
- EXPECT_CALL(*writer_, WritePacket(_, _, _, _, _))
+ EXPECT_CALL(*writer_, WritePacket(_, _, _, _, _, _))
.WillOnce(Return(WriteResult(WRITE_STATUS_OK, 0)));
// Send max stream id (currently 32 bits).
EXPECT_CALL(debug_visitor, OnGoAwayFrameSent(/* stream_id = */ 0xfffffffc));
@@ -1268,7 +1268,7 @@
// In HTTP/3, Qpack stream will send data on stream reset and cause packet to
// be flushed.
if (VersionUsesHttp3(transport_version())) {
- EXPECT_CALL(*writer_, WritePacket(_, _, _, _, _))
+ EXPECT_CALL(*writer_, WritePacket(_, _, _, _, _, _))
.WillOnce(Return(WriteResult(WRITE_STATUS_OK, 0)));
}
EXPECT_CALL(*connection_, SendControlFrame(_));
@@ -1503,7 +1503,7 @@
EXPECT_CALL(*connection_, OnStreamReset(stream->id(), _));
EXPECT_CALL(*connection_, SendControlFrame(_));
} else {
- EXPECT_CALL(*writer_, WritePacket(_, _, _, _, _))
+ EXPECT_CALL(*writer_, WritePacket(_, _, _, _, _, _))
.WillOnce(Return(WriteResult(WRITE_STATUS_OK, 0)));
}
QuicRstStreamFrame rst_frame(kInvalidControlFrameId, stream->id(),
@@ -1782,7 +1782,7 @@
CompleteHandshake();
TestStream* stream = session_.CreateOutgoingBidirectionalStream();
- EXPECT_CALL(*writer_, WritePacket(_, _, _, _, _))
+ EXPECT_CALL(*writer_, WritePacket(_, _, _, _, _, _))
.WillOnce(Return(WriteResult(WRITE_STATUS_OK, 0)));
// Write headers with FIN set to close write side of stream.
// Header block does not matter.
@@ -2838,7 +2838,7 @@
session_.OnSetting(SETTINGS_MAX_FIELD_SECTION_SIZE, 5);
EXPECT_EQ(5u, session_.max_outbound_header_list_size());
- EXPECT_CALL(*writer_, WritePacket(_, _, _, _, _))
+ EXPECT_CALL(*writer_, WritePacket(_, _, _, _, _, _))
.WillRepeatedly(Return(WriteResult(WRITE_STATUS_OK, 0)));
QpackEncoder* qpack_encoder = session_.qpack_encoder();
EXPECT_EQ(0u, QpackEncoderPeer::maximum_blocked_streams(qpack_encoder));
@@ -3065,7 +3065,7 @@
QuicUtils::StreamIdDelta(transport_version())));
// Close connection.
- EXPECT_CALL(*writer_, WritePacket(_, _, _, _, _))
+ EXPECT_CALL(*writer_, WritePacket(_, _, _, _, _, _))
.WillRepeatedly(Return(WriteResult(WRITE_STATUS_OK, 0)));
EXPECT_CALL(*connection_, CloseConnection(QUIC_NO_ERROR, _, _))
.WillOnce(
diff --git a/quiche/quic/core/quic_connection.cc b/quiche/quic/core/quic_connection.cc
index 3e575f2..6fd85b7 100644
--- a/quiche/quic/core/quic_connection.cc
+++ b/quiche/quic/core/quic_connection.cc
@@ -3251,7 +3251,7 @@
QuicTime QuicConnection::CalculatePacketSentTime() {
const QuicTime now = clock_->Now();
- if (!supports_release_time_ || per_packet_options_ == nullptr) {
+ if (!supports_release_time_) {
// Don't change the release delay.
return now;
}
@@ -3261,8 +3261,8 @@
// Release before |now| is impossible.
QuicTime next_release_time =
std::max(now, next_release_time_result.release_time);
- per_packet_options_->release_time_delay = next_release_time - now;
- per_packet_options_->allow_burst = next_release_time_result.allow_burst;
+ packet_writer_params_.release_time_delay = next_release_time - now;
+ packet_writer_params_.allow_burst = next_release_time_result.allow_burst;
return next_release_time;
}
@@ -3929,7 +3929,7 @@
return;
}
QUIC_DVLOG(1) << ENDPOINT << "ECN feedback is invalid, stop marking.";
- ClearEcnCodepoint();
+ packet_writer_params_.ecn_codepoint = ECN_NOT_ECT;
}
std::unique_ptr<QuicSelfIssuedConnectionIdManager>
@@ -4073,7 +4073,8 @@
QuicEcnCodepoint QuicConnection::GetEcnCodepointToSend(
const QuicSocketAddress& destination_address) const {
- const QuicEcnCodepoint original_codepoint = GetNextEcnCodepoint();
+ const QuicEcnCodepoint original_codepoint =
+ packet_writer_params_.ecn_codepoint;
if (disable_ecn_codepoint_validation_) {
return original_codepoint;
}
@@ -4106,24 +4107,16 @@
return original_codepoint;
}
-void QuicConnection::ClearEcnCodepoint() { MaybeSetEcnCodepoint(ECN_NOT_ECT); }
-
-void QuicConnection::MaybeSetEcnCodepoint(QuicEcnCodepoint ecn_codepoint) {
- if (per_packet_options_ != nullptr) {
- per_packet_options_->ecn_codepoint = ecn_codepoint;
- }
-}
-
WriteResult QuicConnection::SendPacketToWriter(
const char* buffer, size_t buf_len, const QuicIpAddress& self_address,
const QuicSocketAddress& destination_address, QuicPacketWriter* writer,
const QuicEcnCodepoint ecn_codepoint) {
- QuicEcnCodepoint original_codepoint = GetNextEcnCodepoint();
+ QuicPacketWriterParams params = packet_writer_params_;
+ params.ecn_codepoint = ecn_codepoint;
last_ecn_codepoint_sent_ = ecn_codepoint;
- MaybeSetEcnCodepoint(ecn_codepoint);
- WriteResult result = writer->WritePacket(
- buffer, buf_len, self_address, destination_address, per_packet_options_);
- MaybeSetEcnCodepoint(original_codepoint);
+ WriteResult result =
+ writer->WritePacket(buffer, buf_len, self_address, destination_address,
+ per_packet_options_, params);
return result;
}
@@ -4231,7 +4224,7 @@
if (!HasQueuedData() && !retransmission_alarm_->IsSet()) {
SetRetransmissionAlarm();
}
- if (GetNextEcnCodepoint() == ECN_NOT_ECT ||
+ if (packet_writer_params_.ecn_codepoint == ECN_NOT_ECT ||
default_path_.ecn_marked_packet_acked) {
return;
}
diff --git a/quiche/quic/core/quic_connection.h b/quiche/quic/core/quic_connection.h
index 8274be2..a89e915 100644
--- a/quiche/quic/core/quic_connection.h
+++ b/quiche/quic/core/quic_connection.h
@@ -1319,6 +1319,20 @@
return sent_server_preferred_address_;
}
+ // Sets the ECN marking for all outgoing packets, assuming that the congestion
+ // control supports that codepoint. QuicConnection will revert to sending
+ // ECN_NOT_ECT if there is evidence the path is dropping ECN-marked packets,
+ // or if the peer provides invalid ECN feedback.
+ void set_ecn_codepoint(QuicEcnCodepoint ecn_codepoint) {
+ if (GetQuicReloadableFlag(quic_send_ect1)) {
+ packet_writer_params_.ecn_codepoint = ecn_codepoint;
+ }
+ }
+
+ QuicEcnCodepoint ecn_codepoint() const {
+ return packet_writer_params_.ecn_codepoint;
+ }
+
protected:
// Calls cancel() on all the alarms owned by this connection.
void CancelAllAlarms();
@@ -1985,25 +1999,10 @@
// Returns true if |address| is known server address.
bool IsKnownServerAddress(const QuicSocketAddress& address) const;
- // Retrieves the ECN codepoint stored in per_packet_options_, unless the flag
- // is not set.
- QuicEcnCodepoint GetNextEcnCodepoint() const {
- return (per_packet_options_ != nullptr &&
- GetQuicReloadableFlag(quic_send_ect1))
- ? per_packet_options_->ecn_codepoint
- : ECN_NOT_ECT;
- }
-
// Retrieves the ECN codepoint to be sent on the next packet.
QuicEcnCodepoint GetEcnCodepointToSend(
const QuicSocketAddress& destination_address) const;
- // Sets the ECN codepoint to Not-ECT.
- void ClearEcnCodepoint();
-
- // Set the ECN codepoint, but only if set_per_packet_options has been called.
- void MaybeSetEcnCodepoint(QuicEcnCodepoint ecn_codepoint);
-
// Writes the packet to |writer| with the ECN mark specified in
// |ecn_codepoint|. Will also set last_ecn_sent_ appropriately.
WriteResult SendPacketToWriter(const char* buffer, size_t buf_len,
@@ -2033,6 +2032,7 @@
QuicConnectionHelperInterface* helper_; // Not owned.
QuicAlarmFactory* alarm_factory_; // Not owned.
PerPacketOptions* per_packet_options_; // Not owned.
+ QuicPacketWriterParams packet_writer_params_;
QuicPacketWriter* writer_; // Owned or not depending on |owns_writer_|.
bool owns_writer_;
// Encryption level for new packets. Should only be changed via
diff --git a/quiche/quic/core/quic_connection_test.cc b/quiche/quic/core/quic_connection_test.cc
index 5db68ba..4e326fd 100644
--- a/quiche/quic/core/quic_connection_test.cc
+++ b/quiche/quic/core/quic_connection_test.cc
@@ -17110,10 +17110,8 @@
TEST_P(QuicConnectionTest, EcnCodepointsRejected) {
SetQuicReloadableFlag(quic_send_ect1, true);
- TestPerPacketOptions per_packet_options;
- connection_.set_per_packet_options(&per_packet_options);
for (QuicEcnCodepoint ecn : {ECN_NOT_ECT, ECN_ECT0, ECN_ECT1, ECN_CE}) {
- per_packet_options.ecn_codepoint = ecn;
+ connection_.set_ecn_codepoint(ecn);
if (ecn == ECN_ECT0) {
EXPECT_CALL(*send_algorithm_, SupportsECT0()).WillOnce(Return(false));
} else if (ecn == ECN_ECT1) {
@@ -17121,17 +17119,15 @@
}
EXPECT_CALL(connection_, OnSerializedPacket(_));
SendPing();
- EXPECT_EQ(per_packet_options.ecn_codepoint, ecn);
+ EXPECT_EQ(connection_.ecn_codepoint(), ecn);
EXPECT_EQ(writer_->last_ecn_sent(), ECN_NOT_ECT);
}
}
TEST_P(QuicConnectionTest, EcnCodepointsAccepted) {
SetQuicReloadableFlag(quic_send_ect1, true);
- TestPerPacketOptions per_packet_options;
- connection_.set_per_packet_options(&per_packet_options);
for (QuicEcnCodepoint ecn : {ECN_NOT_ECT, ECN_ECT0, ECN_ECT1, ECN_CE}) {
- per_packet_options.ecn_codepoint = ecn;
+ connection_.set_ecn_codepoint(ecn);
if (ecn == ECN_ECT0) {
EXPECT_CALL(*send_algorithm_, SupportsECT0()).WillOnce(Return(true));
} else if (ecn == ECN_ECT1) {
@@ -17143,34 +17139,30 @@
if (ecn == ECN_CE) {
expected_codepoint = ECN_NOT_ECT;
}
- EXPECT_EQ(per_packet_options.ecn_codepoint, ecn);
+ EXPECT_EQ(connection_.ecn_codepoint(), ecn);
EXPECT_EQ(writer_->last_ecn_sent(), expected_codepoint);
}
}
TEST_P(QuicConnectionTest, EcnCodepointsRejectedIfFlagIsFalse) {
SetQuicReloadableFlag(quic_send_ect1, false);
- TestPerPacketOptions per_packet_options;
- connection_.set_per_packet_options(&per_packet_options);
for (QuicEcnCodepoint ecn : {ECN_NOT_ECT, ECN_ECT0, ECN_ECT1, ECN_CE}) {
- per_packet_options.ecn_codepoint = ecn;
+ connection_.set_ecn_codepoint(ecn);
EXPECT_CALL(connection_, OnSerializedPacket(_));
SendPing();
- EXPECT_EQ(per_packet_options.ecn_codepoint, ECN_NOT_ECT);
+ EXPECT_EQ(connection_.ecn_codepoint(), ECN_NOT_ECT);
EXPECT_EQ(writer_->last_ecn_sent(), ECN_NOT_ECT);
}
}
TEST_P(QuicConnectionTest, EcnValidationDisabled) {
SetQuicReloadableFlag(quic_send_ect1, true);
- TestPerPacketOptions per_packet_options;
- connection_.set_per_packet_options(&per_packet_options);
QuicConnectionPeer::DisableEcnCodepointValidation(&connection_);
for (QuicEcnCodepoint ecn : {ECN_NOT_ECT, ECN_ECT0, ECN_ECT1, ECN_CE}) {
- per_packet_options.ecn_codepoint = ecn;
+ connection_.set_ecn_codepoint(ecn);
EXPECT_CALL(connection_, OnSerializedPacket(_));
SendPing();
- EXPECT_EQ(per_packet_options.ecn_codepoint, ecn);
+ EXPECT_EQ(connection_.ecn_codepoint(), ecn);
EXPECT_EQ(writer_->last_ecn_sent(), ecn);
}
}
@@ -17178,26 +17170,22 @@
TEST_P(QuicConnectionTest, RtoDisablesEcnMarking) {
SetQuicReloadableFlag(quic_send_ect1, true);
EXPECT_CALL(*send_algorithm_, SupportsECT1()).WillRepeatedly(Return(true));
- TestPerPacketOptions per_packet_options;
- per_packet_options.ecn_codepoint = ECN_ECT1;
- connection_.set_per_packet_options(&per_packet_options);
+ connection_.set_ecn_codepoint(ECN_ECT1);
QuicPacketCreatorPeer::SetPacketNumber(
QuicConnectionPeer::GetPacketCreator(&connection_), 1);
SendPing();
connection_.OnRetransmissionTimeout();
EXPECT_EQ(writer_->last_ecn_sent(), ECN_NOT_ECT);
- EXPECT_EQ(per_packet_options.ecn_codepoint, ECN_ECT1);
+ EXPECT_EQ(connection_.ecn_codepoint(), ECN_ECT1);
// On 2nd RTO, QUIC abandons ECN.
connection_.OnRetransmissionTimeout();
EXPECT_EQ(writer_->last_ecn_sent(), ECN_NOT_ECT);
- EXPECT_EQ(per_packet_options.ecn_codepoint, ECN_NOT_ECT);
+ EXPECT_EQ(connection_.ecn_codepoint(), ECN_NOT_ECT);
}
TEST_P(QuicConnectionTest, RtoDoesntDisableEcnMarkingIfEcnAcked) {
EXPECT_CALL(*send_algorithm_, SupportsECT1()).WillRepeatedly(Return(true));
- TestPerPacketOptions per_packet_options;
- per_packet_options.ecn_codepoint = ECN_ECT1;
- connection_.set_per_packet_options(&per_packet_options);
+ connection_.set_ecn_codepoint(ECN_ECT1);
QuicPacketCreatorPeer::SetPacketNumber(
QuicConnectionPeer::GetPacketCreator(&connection_), 1);
if (!GetQuicReloadableFlag(quic_send_ect1)) {
@@ -17213,18 +17201,17 @@
QuicEcnCodepoint expected_codepoint =
GetQuicReloadableFlag(quic_send_ect1) ? ECN_ECT1 : ECN_NOT_ECT;
EXPECT_EQ(writer_->last_ecn_sent(), expected_codepoint);
- EXPECT_EQ(per_packet_options.ecn_codepoint, expected_codepoint);
+ EXPECT_EQ(connection_.ecn_codepoint(), expected_codepoint);
connection_.OnRetransmissionTimeout();
EXPECT_EQ(writer_->last_ecn_sent(), expected_codepoint);
- EXPECT_EQ(per_packet_options.ecn_codepoint, expected_codepoint);
+ EXPECT_EQ(connection_.ecn_codepoint(), expected_codepoint);
}
TEST_P(QuicConnectionTest, InvalidFeedbackCancelsEcn) {
+ SetQuicReloadableFlag(quic_send_ect1, true);
EXPECT_CALL(*send_algorithm_, SupportsECT1()).WillRepeatedly(Return(true));
- TestPerPacketOptions per_packet_options;
- per_packet_options.ecn_codepoint = ECN_ECT1;
- connection_.set_per_packet_options(&per_packet_options);
- EXPECT_EQ(per_packet_options.ecn_codepoint, ECN_ECT1);
+ connection_.set_ecn_codepoint(ECN_ECT1);
+ EXPECT_EQ(connection_.ecn_codepoint(), ECN_ECT1);
if (!GetQuicReloadableFlag(quic_send_ect1)) {
EXPECT_QUIC_BUG(connection_.OnInvalidEcnFeedback(),
"Unexpected call to OnInvalidEcnFeedback\\(\\)\\.");
@@ -17232,15 +17219,13 @@
} else {
connection_.OnInvalidEcnFeedback();
}
- EXPECT_EQ(per_packet_options.ecn_codepoint, ECN_NOT_ECT);
+ EXPECT_EQ(connection_.ecn_codepoint(), ECN_NOT_ECT);
}
TEST_P(QuicConnectionTest, StateMatchesSentEcn) {
SetQuicReloadableFlag(quic_send_ect1, true);
EXPECT_CALL(*send_algorithm_, SupportsECT1()).WillRepeatedly(Return(true));
- TestPerPacketOptions per_packet_options;
- per_packet_options.ecn_codepoint = ECN_ECT1;
- connection_.set_per_packet_options(&per_packet_options);
+ connection_.set_ecn_codepoint(ECN_ECT1);
SendPing();
QuicSentPacketManager* sent_packet_manager =
QuicConnectionPeer::GetSentPacketManager(&connection_);
@@ -17256,9 +17241,7 @@
}
SetQuicReloadableFlag(quic_send_ect1, true);
EXPECT_CALL(*send_algorithm_, SupportsECT1()).WillRepeatedly(Return(true));
- TestPerPacketOptions per_packet_options;
- per_packet_options.ecn_codepoint = ECN_ECT1;
- connection_.set_per_packet_options(&per_packet_options);
+ connection_.set_ecn_codepoint(ECN_ECT1);
// All these steps are necessary to send an INITIAL ping and save it to be
// coalesced, instead of just calling SendPing() and sending it immediately.
char buffer[1000];
@@ -17272,7 +17255,7 @@
creator_->set_encryption_level(ENCRYPTION_FORWARD_SECURE);
EXPECT_CALL(*send_algorithm_, SupportsECT0()).WillRepeatedly(Return(true));
// If not for the line below, these packets would coalesce.
- per_packet_options.ecn_codepoint = ECN_ECT0;
+ connection_.set_ecn_codepoint(ECN_ECT0);
EXPECT_EQ(writer_->packets_write_attempts(), 0);
SendPing();
EXPECT_EQ(writer_->packets_write_attempts(), 2);
@@ -17282,14 +17265,12 @@
TEST_P(QuicConnectionTest, BufferedPacketRetainsOldEcn) {
SetQuicReloadableFlag(quic_send_ect1, true);
EXPECT_CALL(*send_algorithm_, SupportsECT1()).WillRepeatedly(Return(true));
- TestPerPacketOptions per_packet_options;
- per_packet_options.ecn_codepoint = ECN_ECT1;
- connection_.set_per_packet_options(&per_packet_options);
+ connection_.set_ecn_codepoint(ECN_ECT1);
writer_->SetWriteBlocked();
EXPECT_CALL(visitor_, OnWriteBlocked()).Times(2);
SendPing();
EXPECT_CALL(*send_algorithm_, SupportsECT0()).WillRepeatedly(Return(true));
- per_packet_options.ecn_codepoint = ECN_ECT0;
+ connection_.set_ecn_codepoint(ECN_ECT0);
writer_->SetWritable();
connection_.OnCanWrite();
EXPECT_EQ(writer_->last_ecn_sent(), ECN_ECT1);
diff --git a/quiche/quic/core/quic_crypto_stream_test.cc b/quiche/quic/core/quic_crypto_stream_test.cc
index 76f840b..70928ae 100644
--- a/quiche/quic/core/quic_crypto_stream_test.cc
+++ b/quiche/quic/core/quic_crypto_stream_test.cc
@@ -133,7 +133,7 @@
Perspective::IS_CLIENT)),
session_(connection_, /*create_mock_crypto_stream=*/false) {
EXPECT_CALL(*static_cast<MockPacketWriter*>(connection_->writer()),
- WritePacket(_, _, _, _, _))
+ WritePacket(_, _, _, _, _, _))
.WillRepeatedly(Return(WriteResult(WRITE_STATUS_OK, 0)));
stream_ = new MockQuicCryptoStream(&session_);
session_.SetCryptoStream(stream_);
diff --git a/quiche/quic/core/quic_default_packet_writer.cc b/quiche/quic/core/quic_default_packet_writer.cc
index 7eac827..6d45217 100644
--- a/quiche/quic/core/quic_default_packet_writer.cc
+++ b/quiche/quic/core/quic_default_packet_writer.cc
@@ -15,14 +15,13 @@
WriteResult QuicDefaultPacketWriter::WritePacket(
const char* buffer, size_t buf_len, const QuicIpAddress& self_address,
- const QuicSocketAddress& peer_address, PerPacketOptions* options) {
+ const QuicSocketAddress& peer_address, PerPacketOptions* /*options*/,
+ const QuicPacketWriterParams& params) {
QUICHE_DCHECK(!write_blocked_);
QuicUdpPacketInfo packet_info;
packet_info.SetPeerAddress(peer_address);
packet_info.SetSelfIp(self_address);
- if (options != nullptr) {
- packet_info.SetEcnCodepoint(options->ecn_codepoint);
- }
+ packet_info.SetEcnCodepoint(params.ecn_codepoint);
WriteResult result =
QuicUdpSocketApi().WritePacket(fd_, buffer, buf_len, packet_info);
if (IsWriteBlockedStatus(result.status)) {
diff --git a/quiche/quic/core/quic_default_packet_writer.h b/quiche/quic/core/quic_default_packet_writer.h
index 718f8eb..c513362 100644
--- a/quiche/quic/core/quic_default_packet_writer.h
+++ b/quiche/quic/core/quic_default_packet_writer.h
@@ -28,7 +28,8 @@
WriteResult WritePacket(const char* buffer, size_t buf_len,
const QuicIpAddress& self_address,
const QuicSocketAddress& peer_address,
- PerPacketOptions* options) override;
+ PerPacketOptions* options,
+ const QuicPacketWriterParams& params) override;
bool IsWriteBlocked() const override;
void SetWritable() override;
absl::optional<int> MessageTooBigErrorCode() const override;
diff --git a/quiche/quic/core/quic_dispatcher_test.cc b/quiche/quic/core/quic_dispatcher_test.cc
index ff2516a..37d6185 100644
--- a/quiche/quic/core/quic_dispatcher_test.cc
+++ b/quiche/quic/core/quic_dispatcher_test.cc
@@ -1544,7 +1544,8 @@
WriteResult WritePacket(const char* buffer, size_t buf_len,
const QuicIpAddress& /*self_client_address*/,
const QuicSocketAddress& /*peer_client_address*/,
- PerPacketOptions* /*options*/) override {
+ PerPacketOptions* /*options*/,
+ const QuicPacketWriterParams& /*params*/) override {
packets_.push_back(
QuicEncryptedPacket(buffer, buf_len, /*owns_buffer=*/false).Clone());
return WriteResult(WRITE_STATUS_OK, buf_len);
@@ -1877,7 +1878,8 @@
WriteResult WritePacket(const char* /*buffer*/, size_t /*buf_len*/,
const QuicIpAddress& /*self_client_address*/,
const QuicSocketAddress& /*peer_client_address*/,
- PerPacketOptions* /*options*/) override {
+ PerPacketOptions* /*options*/,
+ const QuicPacketWriterParams& /*params*/) override {
// It would be quite possible to actually implement this method here with
// the fake blocked status, but it would be significantly more work in
// Chromium, and since it's not called anyway, don't bother.
diff --git a/quiche/quic/core/quic_linux_socket_utils.h b/quiche/quic/core/quic_linux_socket_utils.h
index de80dfd..8d53e47 100644
--- a/quiche/quic/core/quic_linux_socket_utils.h
+++ b/quiche/quic/core/quic_linux_socket_utils.h
@@ -109,18 +109,19 @@
const QuicSocketAddress& peer_address)
: BufferedWrite(buffer, buf_len, self_address, peer_address,
std::unique_ptr<PerPacketOptions>(),
- /*release_time=*/0) {}
+ QuicPacketWriterParams(), /*release_time=*/0) {}
BufferedWrite(const char* buffer, size_t buf_len,
const QuicIpAddress& self_address,
const QuicSocketAddress& peer_address,
std::unique_ptr<PerPacketOptions> options,
- uint64_t release_time)
+ const QuicPacketWriterParams& params, uint64_t release_time)
: buffer(buffer),
buf_len(buf_len),
self_address(self_address),
peer_address(peer_address),
options(std::move(options)),
+ params(params),
release_time(release_time) {}
const char* buffer; // Not owned.
@@ -128,6 +129,7 @@
QuicIpAddress self_address;
QuicSocketAddress peer_address;
std::unique_ptr<PerPacketOptions> options;
+ QuicPacketWriterParams params;
// The release time according to the owning packet writer's clock, which is
// often not a QuicClock. Calculated from packet writer's Now() and the
diff --git a/quiche/quic/core/quic_packet_writer.h b/quiche/quic/core/quic_packet_writer.h
index 3e6cb21..c3b3fab 100644
--- a/quiche/quic/core/quic_packet_writer.h
+++ b/quiche/quic/core/quic_packet_writer.h
@@ -18,7 +18,11 @@
struct WriteResult;
-struct QUIC_EXPORT_PRIVATE PerPacketOptions {
+// This class allows a platform to pass instructions to an associated child of
+// QuicWriter without intervening QUIC code understanding anything about its
+// contents.
+class QUIC_EXPORT_PRIVATE PerPacketOptions {
+ public:
virtual ~PerPacketOptions() {}
// Returns a heap-allocated copy of |this|.
@@ -29,7 +33,10 @@
// This method is declared pure virtual in order to ensure the subclasses
// would not forget to override it.
virtual std::unique_ptr<PerPacketOptions> Clone() const = 0;
+};
+// The owner of QuicPacketWriter can pass control information via this struct.
+struct QUIC_EXPORT_PRIVATE QuicPacketWriterParams {
// Specifies ideal release time delay for this packet.
QuicTime::Delta release_time_delay = QuicTime::Delta::Zero();
// Whether it is allowed to send this packet without |release_time_delay|.
@@ -107,7 +114,8 @@
virtual WriteResult WritePacket(const char* buffer, size_t buf_len,
const QuicIpAddress& self_address,
const QuicSocketAddress& peer_address,
- PerPacketOptions* options) = 0;
+ PerPacketOptions* options,
+ const QuicPacketWriterParams& params) = 0;
// Returns true if the network socket is not writable.
virtual bool IsWriteBlocked() const = 0;
diff --git a/quiche/quic/core/quic_packet_writer_wrapper.cc b/quiche/quic/core/quic_packet_writer_wrapper.cc
index c040c91..c3b4b28 100644
--- a/quiche/quic/core/quic_packet_writer_wrapper.cc
+++ b/quiche/quic/core/quic_packet_writer_wrapper.cc
@@ -14,9 +14,10 @@
WriteResult QuicPacketWriterWrapper::WritePacket(
const char* buffer, size_t buf_len, const QuicIpAddress& self_address,
- const QuicSocketAddress& peer_address, PerPacketOptions* options) {
+ const QuicSocketAddress& peer_address, PerPacketOptions* options,
+ const QuicPacketWriterParams& params) {
return writer_->WritePacket(buffer, buf_len, self_address, peer_address,
- options);
+ options, params);
}
bool QuicPacketWriterWrapper::IsWriteBlocked() const {
diff --git a/quiche/quic/core/quic_packet_writer_wrapper.h b/quiche/quic/core/quic_packet_writer_wrapper.h
index 3afeaf1..7d43fdc 100644
--- a/quiche/quic/core/quic_packet_writer_wrapper.h
+++ b/quiche/quic/core/quic_packet_writer_wrapper.h
@@ -27,7 +27,8 @@
WriteResult WritePacket(const char* buffer, size_t buf_len,
const QuicIpAddress& self_address,
const QuicSocketAddress& peer_address,
- PerPacketOptions* options) override;
+ PerPacketOptions* options,
+ const QuicPacketWriterParams& params) override;
bool IsWriteBlocked() const override;
void SetWritable() override;
absl::optional<int> MessageTooBigErrorCode() const override;
diff --git a/quiche/quic/core/quic_path_validator.cc b/quiche/quic/core/quic_path_validator.cc
index 48c21d2..3185664 100644
--- a/quiche/quic/core/quic_path_validator.cc
+++ b/quiche/quic/core/quic_path_validator.cc
@@ -169,7 +169,7 @@
<< path_context_->peer_address();
path_context_->WriterToUse()->WritePacket(
buffer, buf_len, path_context_->self_address().host(),
- path_context_->peer_address(), nullptr);
+ path_context_->peer_address(), nullptr, QuicPacketWriterParams());
}
} // namespace quic
diff --git a/quiche/quic/core/quic_session_test.cc b/quiche/quic/core/quic_session_test.cc
index bdf74b3..9bcbf71 100644
--- a/quiche/quic/core/quic_session_test.cc
+++ b/quiche/quic/core/quic_session_test.cc
@@ -1170,7 +1170,7 @@
// Expect that we only send one packet, the writes from different streams
// should be bundled together.
- EXPECT_CALL(*writer, WritePacket(_, _, _, _, _))
+ EXPECT_CALL(*writer, WritePacket(_, _, _, _, _, _))
.WillOnce(Return(WriteResult(WRITE_STATUS_OK, 0)));
EXPECT_CALL(*send_algorithm, OnPacketSent(_, _, _, _, _));
EXPECT_CALL(*send_algorithm, OnApplicationLimited(_));
@@ -1238,7 +1238,7 @@
MockPacketWriter* writer = static_cast<MockPacketWriter*>(
QuicConnectionPeer::GetWriter(session_.connection()));
EXPECT_CALL(*writer, IsWriteBlocked()).WillRepeatedly(Return(true));
- EXPECT_CALL(*writer, WritePacket(_, _, _, _, _)).Times(0);
+ EXPECT_CALL(*writer, WritePacket(_, _, _, _, _, _)).Times(0);
TestStream* stream2 = session_.CreateOutgoingBidirectionalStream();
@@ -1415,7 +1415,7 @@
connection_->SetDefaultEncryptionLevel(ENCRYPTION_FORWARD_SECURE);
MockPacketWriter* writer = static_cast<MockPacketWriter*>(
QuicConnectionPeer::GetWriter(session_.connection()));
- EXPECT_CALL(*writer, WritePacket(_, _, _, _, _))
+ EXPECT_CALL(*writer, WritePacket(_, _, _, _, _, _))
.WillOnce(Return(WriteResult(WRITE_STATUS_OK, 0)));
EXPECT_CALL(*connection_, SendControlFrame(_))
@@ -1471,7 +1471,7 @@
MockPacketWriter* writer = static_cast<MockPacketWriter*>(
QuicConnectionPeer::GetWriter(session_.connection()));
- EXPECT_CALL(*writer, WritePacket(_, _, _, new_peer_address, _))
+ EXPECT_CALL(*writer, WritePacket(_, _, _, new_peer_address, _, _))
.WillOnce(Return(WriteResult(WRITE_STATUS_OK, 0)));
EXPECT_CALL(*connection_, SendConnectivityProbingPacket(_, _))
@@ -3123,7 +3123,7 @@
CompleteHandshake();
MockPacketWriter* writer = static_cast<MockPacketWriter*>(
QuicConnectionPeer::GetWriter(session_.connection()));
- EXPECT_CALL(*writer, WritePacket(_, _, _, _, _))
+ EXPECT_CALL(*writer, WritePacket(_, _, _, _, _, _))
.WillOnce(Return(WriteResult(WRITE_STATUS_OK, 0)));
// Set a small connection level flow control limit.
const uint64_t kWindow = 36;
diff --git a/quiche/quic/core/quic_time_wait_list_manager.cc b/quiche/quic/core/quic_time_wait_list_manager.cc
index d479973..484d35e 100644
--- a/quiche/quic/core/quic_time_wait_list_manager.cc
+++ b/quiche/quic/core/quic_time_wait_list_manager.cc
@@ -377,7 +377,7 @@
WriteResult result = writer_->WritePacket(
queued_packet->packet()->data(), queued_packet->packet()->length(),
queued_packet->self_address().host(), queued_packet->peer_address(),
- nullptr);
+ nullptr, QuicPacketWriterParams());
// If using a batch writer and the packet is buffered, flush it.
if (writer_->IsBatchMode() && result.status == WRITE_STATUS_OK &&
diff --git a/quiche/quic/core/quic_time_wait_list_manager_test.cc b/quiche/quic/core/quic_time_wait_list_manager_test.cc
index eef0b99..9b2f36f 100644
--- a/quiche/quic/core/quic_time_wait_list_manager_test.cc
+++ b/quiche/quic/core/quic_time_wait_list_manager_test.cc
@@ -236,7 +236,7 @@
connection_id_, EmptyQuicConnectionId(), /*ietf_quic=*/false,
/*use_length_prefix=*/false, AllSupportedVersions()));
EXPECT_CALL(writer_, WritePacket(_, packet->length(), self_address_.host(),
- peer_address_, _))
+ peer_address_, _, _))
.WillOnce(Return(WriteResult(WRITE_STATUS_OK, 1)));
time_wait_list_manager_.SendVersionNegotiationPacket(
@@ -253,7 +253,7 @@
connection_id_, EmptyQuicConnectionId(), /*ietf_quic=*/true,
/*use_length_prefix=*/false, AllSupportedVersions()));
EXPECT_CALL(writer_, WritePacket(_, packet->length(), self_address_.host(),
- peer_address_, _))
+ peer_address_, _, _))
.WillOnce(Return(WriteResult(WRITE_STATUS_OK, 1)));
time_wait_list_manager_.SendVersionNegotiationPacket(
@@ -269,7 +269,7 @@
connection_id_, EmptyQuicConnectionId(), /*ietf_quic=*/true,
/*use_length_prefix=*/true, AllSupportedVersions()));
EXPECT_CALL(writer_, WritePacket(_, packet->length(), self_address_.host(),
- peer_address_, _))
+ peer_address_, _, _))
.WillOnce(Return(WriteResult(WRITE_STATUS_OK, 1)));
time_wait_list_manager_.SendVersionNegotiationPacket(
@@ -286,7 +286,7 @@
connection_id_, TestConnectionId(0x33), /*ietf_quic=*/true,
/*use_length_prefix=*/true, AllSupportedVersions()));
EXPECT_CALL(writer_, WritePacket(_, packet->length(), self_address_.host(),
- peer_address_, _))
+ peer_address_, _, _))
.WillOnce(Return(WriteResult(WRITE_STATUS_OK, 1)));
time_wait_list_manager_.SendVersionNegotiationPacket(
@@ -307,7 +307,7 @@
QuicTimeWaitListManager::SEND_CONNECTION_CLOSE_PACKETS,
&termination_packets);
EXPECT_CALL(writer_, WritePacket(_, kConnectionCloseLength,
- self_address_.host(), peer_address_, _))
+ self_address_.host(), peer_address_, _, _))
.WillOnce(Return(WriteResult(WRITE_STATUS_OK, 1)));
ProcessPacket(connection_id_);
@@ -327,7 +327,7 @@
QuicTimeWaitListManager::SEND_CONNECTION_CLOSE_PACKETS,
&termination_packets);
EXPECT_CALL(writer_, WritePacket(_, kConnectionCloseLength,
- self_address_.host(), peer_address_, _))
+ self_address_.host(), peer_address_, _, _))
.Times(2)
.WillOnce(Return(WriteResult(WRITE_STATUS_OK, 1)));
@@ -339,7 +339,7 @@
AddConnectionId(connection_id_,
QuicTimeWaitListManager::SEND_STATELESS_RESET);
EXPECT_CALL(writer_,
- WritePacket(_, _, self_address_.host(), peer_address_, _))
+ WritePacket(_, _, self_address_.host(), peer_address_, _, _))
.With(Args<0, 1>(PublicResetPacketEq(connection_id_)))
.WillOnce(Return(WriteResult(WRITE_STATUS_OK, 0)));
@@ -353,7 +353,7 @@
EXPECT_EQ(1u, time_wait_list_manager_.num_connections());
for (int packet_number = 1; packet_number < 101; ++packet_number) {
if ((packet_number & (packet_number - 1)) == 0) {
- EXPECT_CALL(writer_, WritePacket(_, _, _, _, _))
+ EXPECT_CALL(writer_, WritePacket(_, _, _, _, _, _))
.WillOnce(Return(WriteResult(WRITE_STATUS_OK, 1)));
}
ProcessPacket(connection_id_);
@@ -373,7 +373,7 @@
AddStatelessConnectionId(connection_id_);
EXPECT_CALL(writer_,
- WritePacket(_, _, self_address_.host(), peer_address_, _))
+ WritePacket(_, _, self_address_.host(), peer_address_, _, _))
.WillOnce(Return(WriteResult(WRITE_STATUS_OK, 1)));
ProcessPacket(connection_id_);
@@ -468,14 +468,14 @@
connection_id, EmptyQuicConnectionId(), /*packet_number=*/234));
// Let first write through.
EXPECT_CALL(writer_,
- WritePacket(_, _, self_address_.host(), peer_address_, _))
+ WritePacket(_, _, self_address_.host(), peer_address_, _, _))
.With(Args<0, 1>(PublicResetPacketEq(connection_id)))
.WillOnce(Return(WriteResult(WRITE_STATUS_OK, packet->length())));
ProcessPacket(connection_id);
// write block for the next packet.
EXPECT_CALL(writer_,
- WritePacket(_, _, self_address_.host(), peer_address_, _))
+ WritePacket(_, _, self_address_.host(), peer_address_, _, _))
.With(Args<0, 1>(PublicResetPacketEq(connection_id)))
.WillOnce(DoAll(Assign(&writer_is_blocked_, true),
Return(WriteResult(WRITE_STATUS_BLOCKED, EAGAIN))));
@@ -492,7 +492,7 @@
QuicTimeWaitListManager::SEND_STATELESS_RESET);
std::unique_ptr<QuicEncryptedPacket> other_packet(ConstructEncryptedPacket(
other_connection_id, EmptyQuicConnectionId(), /*packet_number=*/23423));
- EXPECT_CALL(writer_, WritePacket(_, _, _, _, _)).Times(0);
+ EXPECT_CALL(writer_, WritePacket(_, _, _, _, _, _)).Times(0);
EXPECT_CALL(visitor_, OnWriteBlocked(&time_wait_list_manager_));
ProcessPacket(other_connection_id);
EXPECT_EQ(2u, time_wait_list_manager_.num_connections());
@@ -500,11 +500,11 @@
// Now expect all the write blocked public reset packets to be sent again.
writer_is_blocked_ = false;
EXPECT_CALL(writer_,
- WritePacket(_, _, self_address_.host(), peer_address_, _))
+ WritePacket(_, _, self_address_.host(), peer_address_, _, _))
.With(Args<0, 1>(PublicResetPacketEq(connection_id)))
.WillOnce(Return(WriteResult(WRITE_STATUS_OK, packet->length())));
EXPECT_CALL(writer_,
- WritePacket(_, _, self_address_.host(), peer_address_, _))
+ WritePacket(_, _, self_address_.host(), peer_address_, _, _))
.With(Args<0, 1>(PublicResetPacketEq(other_connection_id)))
.WillOnce(Return(WriteResult(WRITE_STATUS_OK, packet->length())));
time_wait_list_manager_.OnBlockedWriterCanWrite();
@@ -527,7 +527,7 @@
EXPECT_EQ(1u, time_wait_list_manager_.num_connections());
EXPECT_CALL(writer_, WritePacket(_, kConnectionCloseLength,
- self_address_.host(), peer_address_, _))
+ self_address_.host(), peer_address_, _, _))
.WillOnce(Return(WriteResult(WRITE_STATUS_OK, 1)));
ProcessPacket(connection_id_);
@@ -653,7 +653,7 @@
// Termination packet is not encrypted, instead, send stateless reset.
EXPECT_CALL(writer_,
- WritePacket(_, _, self_address_.host(), peer_address_, _))
+ WritePacket(_, _, self_address_.host(), peer_address_, _, _))
.With(Args<0, 1>(PublicResetPacketEq(connection_id_)))
.WillOnce(Return(WriteResult(WRITE_STATUS_OK, 0)));
// Processes IETF short header packet.
@@ -677,7 +677,7 @@
TimeWaitConnectionInfo(/*ietf_quic=*/true, &termination_packets,
{connection_id_}));
EXPECT_CALL(writer_, WritePacket(_, kConnectionCloseLength,
- self_address_.host(), peer_address_, _))
+ self_address_.host(), peer_address_, _, _))
.WillOnce(Return(WriteResult(WRITE_STATUS_OK, 1)));
// Processes IETF short header packet.
@@ -707,7 +707,7 @@
active_connection_ids, QuicTime::Delta::Zero()));
EXPECT_CALL(writer_, WritePacket(_, kConnectionCloseLength,
- self_address_.host(), peer_address_, _))
+ self_address_.host(), peer_address_, _, _))
.Times(2)
.WillRepeatedly(Return(WriteResult(WRITE_STATUS_OK, 1)));
// Processes IETF short header packet.
@@ -743,7 +743,7 @@
.Times(testing::AnyNumber());
// Write block for the next packets.
EXPECT_CALL(writer_,
- WritePacket(_, _, self_address_.host(), peer_address_, _))
+ WritePacket(_, _, self_address_.host(), peer_address_, _, _))
.With(Args<0, 1>(PublicResetPacketEq(TestConnectionId(1))))
.WillOnce(DoAll(Assign(&writer_is_blocked_, true),
Return(WriteResult(WRITE_STATUS_BLOCKED, EAGAIN))));
diff --git a/quiche/quic/masque/masque_encapsulated_client.cc b/quiche/quic/masque/masque_encapsulated_client.cc
index d384363..34adde4 100644
--- a/quiche/quic/masque/masque_encapsulated_client.cc
+++ b/quiche/quic/masque/masque_encapsulated_client.cc
@@ -78,7 +78,8 @@
WriteResult WritePacket(const char* buffer, size_t buf_len,
const QuicIpAddress& /*self_address*/,
const QuicSocketAddress& peer_address,
- PerPacketOptions* /*options*/) override {
+ PerPacketOptions* /*options*/,
+ const QuicPacketWriterParams& /*params*/) override {
QUICHE_DCHECK(peer_address.IsInitialized());
QUIC_DVLOG(1) << "MasquePacketWriter trying to write " << buf_len
<< " bytes to " << peer_address;
diff --git a/quiche/quic/qbone/qbone_session_test.cc b/quiche/quic/qbone/qbone_session_test.cc
index 1a9d023..ab92c1c 100644
--- a/quiche/quic/qbone/qbone_session_test.cc
+++ b/quiche/quic/qbone/qbone_session_test.cc
@@ -355,11 +355,12 @@
// Hook everything up!
MockPacketWriter* client_writer = static_cast<MockPacketWriter*>(
QuicConnectionPeer::GetWriter(client_peer_->connection()));
- ON_CALL(*client_writer, WritePacket(_, _, _, _, _))
+ ON_CALL(*client_writer, WritePacket(_, _, _, _, _, _))
.WillByDefault(Invoke([this](const char* buffer, size_t buf_len,
const QuicIpAddress& self_address,
const QuicSocketAddress& peer_address,
- PerPacketOptions* options) {
+ PerPacketOptions* option,
+ const QuicPacketWriterParams& params) {
char* copy = new char[1024 * 1024];
memcpy(copy, buffer, buf_len);
runner_.Schedule([this, copy, buf_len] {
@@ -373,11 +374,12 @@
}));
MockPacketWriter* server_writer = static_cast<MockPacketWriter*>(
QuicConnectionPeer::GetWriter(server_peer_->connection()));
- ON_CALL(*server_writer, WritePacket(_, _, _, _, _))
+ ON_CALL(*server_writer, WritePacket(_, _, _, _, _, _))
.WillByDefault(Invoke([this](const char* buffer, size_t buf_len,
const QuicIpAddress& self_address,
const QuicSocketAddress& peer_address,
- PerPacketOptions* options) {
+ PerPacketOptions* options,
+ const QuicPacketWriterParams& params) {
char* copy = new char[1024 * 1024];
memcpy(copy, buffer, buf_len);
runner_.Schedule([this, copy, buf_len] {
diff --git a/quiche/quic/qbone/qbone_stream_test.cc b/quiche/quic/qbone/qbone_stream_test.cc
index b7cc198..16052bc 100644
--- a/quiche/quic/qbone/qbone_stream_test.cc
+++ b/quiche/quic/qbone/qbone_stream_test.cc
@@ -101,7 +101,8 @@
WriteResult WritePacket(const char* buffer, size_t buf_len,
const QuicIpAddress& self_address,
const QuicSocketAddress& peer_address,
- PerPacketOptions* options) override {
+ PerPacketOptions* options,
+ const QuicPacketWriterParams& params) override {
return WriteResult(WRITE_STATUS_ERROR, 0);
}
diff --git a/quiche/quic/test_tools/bad_packet_writer.cc b/quiche/quic/test_tools/bad_packet_writer.cc
index 1e146c4..7961fe8 100644
--- a/quiche/quic/test_tools/bad_packet_writer.cc
+++ b/quiche/quic/test_tools/bad_packet_writer.cc
@@ -17,13 +17,14 @@
WriteResult BadPacketWriter::WritePacket(const char* buffer, size_t buf_len,
const QuicIpAddress& self_address,
const QuicSocketAddress& peer_address,
- PerPacketOptions* options) {
+ PerPacketOptions* options,
+ const QuicPacketWriterParams& params) {
if (error_code_ == 0 || packet_causing_write_error_ > 0) {
if (packet_causing_write_error_ > 0) {
--packet_causing_write_error_;
}
return QuicPacketWriterWrapper::WritePacket(buffer, buf_len, self_address,
- peer_address, options);
+ peer_address, options, params);
}
// It's time to cause write error.
int error_code = error_code_;
diff --git a/quiche/quic/test_tools/bad_packet_writer.h b/quiche/quic/test_tools/bad_packet_writer.h
index bcf12f5..5f3da24 100644
--- a/quiche/quic/test_tools/bad_packet_writer.h
+++ b/quiche/quic/test_tools/bad_packet_writer.h
@@ -21,7 +21,8 @@
WriteResult WritePacket(const char* buffer, size_t buf_len,
const QuicIpAddress& self_address,
const QuicSocketAddress& peer_address,
- PerPacketOptions* options) override;
+ PerPacketOptions* options,
+ const QuicPacketWriterParams& params) override;
private:
size_t packet_causing_write_error_;
diff --git a/quiche/quic/test_tools/first_flight.cc b/quiche/quic/test_tools/first_flight.cc
index dcdeac3..a0b93fb 100644
--- a/quiche/quic/test_tools/first_flight.cc
+++ b/quiche/quic/test_tools/first_flight.cc
@@ -75,11 +75,14 @@
void OnDelegatedPacket(const char* buffer, size_t buf_len,
const QuicIpAddress& /*self_client_address*/,
const QuicSocketAddress& /*peer_client_address*/,
- PerPacketOptions* /*options*/) override {
+ PerPacketOptions* /*options*/,
+ const QuicPacketWriterParams& params) override {
packets_.emplace_back(
QuicReceivedPacket(buffer, buf_len,
connection_helper_.GetClock()->ApproximateNow(),
- /*owns_buffer=*/false)
+ /*owns_buffer=*/false, /*ttl=*/0, /*ttl_valid=*/true,
+ /*packet_headers=*/nullptr, /*headers_length=*/0,
+ /*owns_header_buffer=*/false, params.ecn_codepoint)
.Clone());
}
diff --git a/quiche/quic/test_tools/first_flight.h b/quiche/quic/test_tools/first_flight.h
index 3896031..948511a 100644
--- a/quiche/quic/test_tools/first_flight.h
+++ b/quiche/quic/test_tools/first_flight.h
@@ -31,7 +31,8 @@
virtual void OnDelegatedPacket(const char* buffer, size_t buf_len,
const QuicIpAddress& self_client_address,
const QuicSocketAddress& peer_client_address,
- PerPacketOptions* options) = 0;
+ PerPacketOptions* options,
+ const QuicPacketWriterParams& params) = 0;
};
// |delegate| MUST be valid for the duration of the DelegatedPacketWriter's
@@ -62,9 +63,10 @@
WriteResult WritePacket(const char* buffer, size_t buf_len,
const QuicIpAddress& self_client_address,
const QuicSocketAddress& peer_client_address,
- PerPacketOptions* options) override {
+ PerPacketOptions* options,
+ const QuicPacketWriterParams& params) override {
delegate_->OnDelegatedPacket(buffer, buf_len, self_client_address,
- peer_client_address, options);
+ peer_client_address, options, params);
return WriteResult(WRITE_STATUS_OK, buf_len);
}
diff --git a/quiche/quic/test_tools/limited_mtu_test_writer.cc b/quiche/quic/test_tools/limited_mtu_test_writer.cc
index fa46be1..8f9bc1c 100644
--- a/quiche/quic/test_tools/limited_mtu_test_writer.cc
+++ b/quiche/quic/test_tools/limited_mtu_test_writer.cc
@@ -13,14 +13,15 @@
WriteResult LimitedMtuTestWriter::WritePacket(
const char* buffer, size_t buf_len, const QuicIpAddress& self_address,
- const QuicSocketAddress& peer_address, PerPacketOptions* options) {
+ const QuicSocketAddress& peer_address, PerPacketOptions* options,
+ const QuicPacketWriterParams& params) {
if (buf_len > mtu_) {
// Drop the packet.
return WriteResult(WRITE_STATUS_OK, buf_len);
}
return QuicPacketWriterWrapper::WritePacket(buffer, buf_len, self_address,
- peer_address, options);
+ peer_address, options, params);
}
} // namespace test
diff --git a/quiche/quic/test_tools/limited_mtu_test_writer.h b/quiche/quic/test_tools/limited_mtu_test_writer.h
index 96cc828..e046872 100644
--- a/quiche/quic/test_tools/limited_mtu_test_writer.h
+++ b/quiche/quic/test_tools/limited_mtu_test_writer.h
@@ -24,7 +24,8 @@
WriteResult WritePacket(const char* buffer, size_t buf_len,
const QuicIpAddress& self_address,
const QuicSocketAddress& peer_address,
- PerPacketOptions* options) override;
+ PerPacketOptions* options,
+ const QuicPacketWriterParams& params) override;
private:
QuicByteCount mtu_;
diff --git a/quiche/quic/test_tools/packet_dropping_test_writer.cc b/quiche/quic/test_tools/packet_dropping_test_writer.cc
index 69aae14..ac9625f 100644
--- a/quiche/quic/test_tools/packet_dropping_test_writer.cc
+++ b/quiche/quic/test_tools/packet_dropping_test_writer.cc
@@ -88,7 +88,8 @@
WriteResult PacketDroppingTestWriter::WritePacket(
const char* buffer, size_t buf_len, const QuicIpAddress& self_address,
- const QuicSocketAddress& peer_address, PerPacketOptions* options) {
+ const QuicSocketAddress& peer_address, PerPacketOptions* options,
+ const QuicPacketWriterParams& params) {
++num_calls_to_write_;
ReleaseOldPackets();
@@ -157,7 +158,7 @@
}
delayed_packets_.push_back(
DelayedWrite(buffer, buf_len, self_address, peer_address,
- std::move(delayed_options), send_time));
+ std::move(delayed_options), params, send_time));
cur_buffer_size_ += buf_len;
// Set the alarm if it's not yet set.
@@ -169,7 +170,7 @@
}
return QuicPacketWriterWrapper::WritePacket(buffer, buf_len, self_address,
- peer_address, options);
+ peer_address, options, params);
}
bool PacketDroppingTestWriter::IsWriteBlocked() const {
@@ -207,7 +208,7 @@
// Grab the next one off the queue and send it.
QuicPacketWriterWrapper::WritePacket(
iter->buffer.data(), iter->buffer.length(), iter->self_address,
- iter->peer_address, iter->options.get());
+ iter->peer_address, iter->options.get(), iter->params);
QUICHE_DCHECK_GE(cur_buffer_size_, iter->buffer.length());
cur_buffer_size_ -= iter->buffer.length();
delayed_packets_.erase(iter);
@@ -239,11 +240,13 @@
PacketDroppingTestWriter::DelayedWrite::DelayedWrite(
const char* buffer, size_t buf_len, const QuicIpAddress& self_address,
const QuicSocketAddress& peer_address,
- std::unique_ptr<PerPacketOptions> options, QuicTime send_time)
+ std::unique_ptr<PerPacketOptions> options,
+ const QuicPacketWriterParams& params, QuicTime send_time)
: buffer(buffer, buf_len),
self_address(self_address),
peer_address(peer_address),
options(std::move(options)),
+ params(params),
send_time(send_time) {}
PacketDroppingTestWriter::DelayedWrite::~DelayedWrite() = default;
diff --git a/quiche/quic/test_tools/packet_dropping_test_writer.h b/quiche/quic/test_tools/packet_dropping_test_writer.h
index a7e91d3..dd83cb3 100644
--- a/quiche/quic/test_tools/packet_dropping_test_writer.h
+++ b/quiche/quic/test_tools/packet_dropping_test_writer.h
@@ -49,7 +49,8 @@
WriteResult WritePacket(const char* buffer, size_t buf_len,
const QuicIpAddress& self_address,
const QuicSocketAddress& peer_address,
- PerPacketOptions* options) override;
+ PerPacketOptions* options,
+ const QuicPacketWriterParams& params) override;
bool IsWriteBlocked() const override;
@@ -142,7 +143,8 @@
DelayedWrite(const char* buffer, size_t buf_len,
const QuicIpAddress& self_address,
const QuicSocketAddress& peer_address,
- std::unique_ptr<PerPacketOptions> options, QuicTime send_time);
+ std::unique_ptr<PerPacketOptions> options,
+ const QuicPacketWriterParams& params, QuicTime send_time);
DelayedWrite(const DelayedWrite&) = delete;
DelayedWrite(DelayedWrite&&) = default;
DelayedWrite& operator=(const DelayedWrite&) = delete;
@@ -153,6 +155,7 @@
QuicIpAddress self_address;
QuicSocketAddress peer_address;
std::unique_ptr<PerPacketOptions> options;
+ QuicPacketWriterParams params;
QuicTime send_time;
};
diff --git a/quiche/quic/test_tools/packet_reordering_writer.cc b/quiche/quic/test_tools/packet_reordering_writer.cc
index 8eb8573..12ff9b4 100644
--- a/quiche/quic/test_tools/packet_reordering_writer.cc
+++ b/quiche/quic/test_tools/packet_reordering_writer.cc
@@ -13,18 +13,19 @@
WriteResult PacketReorderingWriter::WritePacket(
const char* buffer, size_t buf_len, const QuicIpAddress& self_address,
- const QuicSocketAddress& peer_address, PerPacketOptions* options) {
+ const QuicSocketAddress& peer_address, PerPacketOptions* options,
+ const QuicPacketWriterParams& params) {
if (!delay_next_) {
QUIC_VLOG(2) << "Writing a non-delayed packet";
WriteResult wr = QuicPacketWriterWrapper::WritePacket(
- buffer, buf_len, self_address, peer_address, options);
+ buffer, buf_len, self_address, peer_address, options, params);
--num_packets_to_wait_;
if (num_packets_to_wait_ == 0) {
QUIC_VLOG(2) << "Writing a delayed packet";
// It's time to write the delayed packet.
QuicPacketWriterWrapper::WritePacket(
delayed_data_.data(), delayed_data_.length(), delayed_self_address_,
- delayed_peer_address_, delayed_options_.get());
+ delayed_peer_address_, delayed_options_.get(), delayed_params_);
}
return wr;
}
@@ -37,6 +38,7 @@
if (options != nullptr) {
delayed_options_ = options->Clone();
}
+ delayed_params_ = params;
delay_next_ = false;
return WriteResult(WRITE_STATUS_OK, buf_len);
}
diff --git a/quiche/quic/test_tools/packet_reordering_writer.h b/quiche/quic/test_tools/packet_reordering_writer.h
index 53204c5..fb77c0d 100644
--- a/quiche/quic/test_tools/packet_reordering_writer.h
+++ b/quiche/quic/test_tools/packet_reordering_writer.h
@@ -5,6 +5,7 @@
#ifndef QUICHE_QUIC_TEST_TOOLS_PACKET_REORDERING_WRITER_H_
#define QUICHE_QUIC_TEST_TOOLS_PACKET_REORDERING_WRITER_H_
+#include "quiche/quic/core/quic_packet_writer.h"
#include "quiche/quic/core/quic_packet_writer_wrapper.h"
namespace quic {
@@ -25,7 +26,8 @@
WriteResult WritePacket(const char* buffer, size_t buf_len,
const QuicIpAddress& self_address,
const QuicSocketAddress& peer_address,
- PerPacketOptions* options) override;
+ PerPacketOptions* options,
+ const QuicPacketWriterParams& params) override;
void SetDelay(size_t num_packets_to_wait);
@@ -36,6 +38,7 @@
QuicIpAddress delayed_self_address_;
QuicSocketAddress delayed_peer_address_;
std::unique_ptr<PerPacketOptions> delayed_options_;
+ QuicPacketWriterParams delayed_params_;
};
} // namespace test
diff --git a/quiche/quic/test_tools/quic_test_utils.cc b/quiche/quic/test_tools/quic_test_utils.cc
index e622ed8..e04f0ca 100644
--- a/quiche/quic/test_tools/quic_test_utils.cc
+++ b/quiche/quic/test_tools/quic_test_utils.cc
@@ -1301,10 +1301,10 @@
}
}
-WriteResult TestPacketWriter::WritePacket(const char* buffer, size_t buf_len,
- const QuicIpAddress& self_address,
- const QuicSocketAddress& peer_address,
- PerPacketOptions* options) {
+WriteResult TestPacketWriter::WritePacket(
+ const char* buffer, size_t buf_len, const QuicIpAddress& self_address,
+ const QuicSocketAddress& peer_address, PerPacketOptions* /*options*/,
+ const QuicPacketWriterParams& params) {
last_write_source_address_ = self_address;
last_write_peer_address_ = peer_address;
// If the buffer is allocated from the pool, return it back to the pool.
@@ -1377,7 +1377,7 @@
bytes_buffered_ += last_packet_size_;
return WriteResult(WRITE_STATUS_OK, 0);
}
- last_ecn_sent_ = (options == nullptr) ? ECN_NOT_ECT : options->ecn_codepoint;
+ last_ecn_sent_ = params.ecn_codepoint;
return WriteResult(WRITE_STATUS_OK, last_packet_size_);
}
diff --git a/quiche/quic/test_tools/quic_test_utils.h b/quiche/quic/test_tools/quic_test_utils.h
index 7b5667a..e368259 100644
--- a/quiche/quic/test_tools/quic_test_utils.h
+++ b/quiche/quic/test_tools/quic_test_utils.h
@@ -1185,7 +1185,8 @@
MOCK_METHOD(WriteResult, WritePacket,
(const char*, size_t buf_len, const QuicIpAddress& self_address,
- const QuicSocketAddress& peer_address, PerPacketOptions*),
+ const QuicSocketAddress& peer_address, PerPacketOptions*,
+ const QuicPacketWriterParams&),
(override));
MOCK_METHOD(bool, IsWriteBlocked, (), (const, override));
MOCK_METHOD(void, SetWritable, (), (override));
@@ -1832,7 +1833,8 @@
WriteResult WritePacket(const char* buffer, size_t buf_len,
const QuicIpAddress& self_address,
const QuicSocketAddress& peer_address,
- PerPacketOptions* options) override;
+ PerPacketOptions* options,
+ const QuicPacketWriterParams& params) override;
bool ShouldWriteFail() { return write_should_fail_; }
@@ -2177,13 +2179,6 @@
return result;
}
-struct TestPerPacketOptions : PerPacketOptions {
- public:
- std::unique_ptr<quic::PerPacketOptions> Clone() const override {
- return std::make_unique<TestPerPacketOptions>(*this);
- }
-};
-
} // namespace test
} // namespace quic
diff --git a/quiche/quic/test_tools/simulator/quic_endpoint_base.cc b/quiche/quic/test_tools/simulator/quic_endpoint_base.cc
index d466c96..3ff517a 100644
--- a/quiche/quic/test_tools/simulator/quic_endpoint_base.cc
+++ b/quiche/quic/test_tools/simulator/quic_endpoint_base.cc
@@ -122,7 +122,8 @@
WriteResult QuicEndpointBase::Writer::WritePacket(
const char* buffer, size_t buf_len, const QuicIpAddress& /*self_address*/,
- const QuicSocketAddress& /*peer_address*/, PerPacketOptions* options) {
+ const QuicSocketAddress& /*peer_address*/, PerPacketOptions* options,
+ const QuicPacketWriterParams& /*params*/) {
QUICHE_DCHECK(!IsWriteBlocked());
QUICHE_DCHECK(options == nullptr);
QUICHE_DCHECK(buf_len <= kMaxOutgoingPacketSize);
diff --git a/quiche/quic/test_tools/simulator/quic_endpoint_base.h b/quiche/quic/test_tools/simulator/quic_endpoint_base.h
index 540b285..c734b81 100644
--- a/quiche/quic/test_tools/simulator/quic_endpoint_base.h
+++ b/quiche/quic/test_tools/simulator/quic_endpoint_base.h
@@ -79,7 +79,8 @@
WriteResult WritePacket(const char* buffer, size_t buf_len,
const QuicIpAddress& self_address,
const QuicSocketAddress& peer_address,
- PerPacketOptions* options) override;
+ PerPacketOptions* options,
+ const QuicPacketWriterParams& params) override;
bool IsWriteBlocked() const override;
void SetWritable() override;
absl::optional<int> MessageTooBigErrorCode() const override;
diff --git a/quiche/quic/tools/quic_client_default_network_helper.cc b/quiche/quic/tools/quic_client_default_network_helper.cc
index 424b8b9..9c1e4e5 100644
--- a/quiche/quic/tools/quic_client_default_network_helper.cc
+++ b/quiche/quic/tools/quic_client_default_network_helper.cc
@@ -30,9 +30,10 @@
WriteResult WritePacket(const char* buffer, size_t buf_len,
const QuicIpAddress& self_address,
const QuicSocketAddress& peer_address,
- PerPacketOptions* options) override {
+ PerPacketOptions* options,
+ const QuicPacketWriterParams& params) override {
WriteResult result = QuicDefaultPacketWriter::WritePacket(
- buffer, buf_len, self_address, peer_address, options);
+ buffer, buf_len, self_address, peer_address, options, params);
if (IsWriteBlockedStatus(result.status)) {
bool success = event_loop_->RearmSocket(fd(), kSocketEventWritable);
QUICHE_DCHECK(success);
