This is an automated email from the ASF dual-hosted git repository.
maskit pushed a commit to branch quic-latest
in repository https://gitbox.apache.org/repos/asf/trafficserver.git
The following commit(s) were added to refs/heads/quic-latest by this push:
new 7a3af4e Remove QUICPacketTransmitter
7a3af4e is described below
commit 7a3af4e1c3251dbd5467810b0d22ba75808e4024
Author: Masakazu Kitajo <[email protected]>
AuthorDate: Wed Feb 27 16:05:54 2019 +0900
Remove QUICPacketTransmitter
It's not used now. We might need it later but a fresh design would be
better.
---
iocore/net/P_QUICNetVConnection.h | 4 --
iocore/net/QUICNetVConnection.cc | 24 +------
iocore/net/quic/Mock.h | 46 ++----------
iocore/net/quic/QUICConnection.h | 3 +-
iocore/net/quic/QUICFrameHandler.h | 2 +
iocore/net/quic/QUICLossDetector.cc | 15 ++--
iocore/net/quic/QUICLossDetector.h | 13 ++--
iocore/net/quic/QUICPacketTransmitter.h | 44 ------------
iocore/net/quic/test/test_QUICAckFrameCreator.cc | 90 ++++++++++++------------
iocore/net/quic/test/test_QUICFlowController.cc | 56 +++++++--------
iocore/net/quic/test/test_QUICFrameDispatcher.cc | 3 +-
iocore/net/quic/test/test_QUICLossDetector.cc | 16 ++---
iocore/net/quic/test/test_QUICStream.cc | 64 ++++++++---------
13 files changed, 128 insertions(+), 252 deletions(-)
diff --git a/iocore/net/P_QUICNetVConnection.h
b/iocore/net/P_QUICNetVConnection.h
index f8a9132..bdece52 100644
--- a/iocore/net/P_QUICNetVConnection.h
+++ b/iocore/net/P_QUICNetVConnection.h
@@ -212,10 +212,6 @@ public:
std::string_view negotiated_application_name() const override;
bool is_closed() const override;
- // QUICConnection (QUICPacketTransmitter)
- virtual void retransmit_packet(const QUICPacket &packet) override;
- virtual Ptr<ProxyMutex> get_packet_transmitter_mutex() override;
-
// QUICConnection (QUICFrameHandler)
std::vector<QUICFrameType> interests() override;
QUICConnectionErrorUPtr handle_frame(QUICEncryptionLevel level, const
QUICFrame &frame) override;
diff --git a/iocore/net/QUICNetVConnection.cc b/iocore/net/QUICNetVConnection.cc
index d16542d..f2d3dfb 100644
--- a/iocore/net/QUICNetVConnection.cc
+++ b/iocore/net/QUICNetVConnection.cc
@@ -92,7 +92,6 @@ QUICNetVConnection::init(QUICConnectionId peer_cid,
QUICConnectionId original_ci
QUICPacketHandler *packet_handler)
{
SET_HANDLER((NetVConnHandler)&QUICNetVConnection::startEvent);
- this->_packet_transmitter_mutex = new_ProxyMutex();
this->_udp_con = udp_con;
this->_packet_handler = packet_handler;
this->_peer_quic_connection_id = peer_cid;
@@ -117,7 +116,6 @@ QUICNetVConnection::init(QUICConnectionId peer_cid,
QUICConnectionId original_ci
UDPConnection *udp_con, QUICPacketHandler
*packet_handler, QUICConnectionTable *ctable)
{
SET_HANDLER((NetVConnHandler)&QUICNetVConnection::acceptEvent);
- this->_packet_transmitter_mutex = new_ProxyMutex();
this->_udp_con = udp_con;
this->_packet_handler = packet_handler;
this->_peer_quic_connection_id = peer_cid;
@@ -271,7 +269,7 @@ QUICNetVConnection::start()
this->_congestion_controller = new QUICCongestionController(this);
for (auto s : QUIC_PN_SPACES) {
int index = static_cast<int>(s);
- QUICLossDetector *ld = new QUICLossDetector(this, this,
this->_congestion_controller, &this->_rtt_measure, index);
+ QUICLossDetector *ld = new QUICLossDetector(this,
this->_congestion_controller, &this->_rtt_measure, index);
this->_frame_dispatcher->add_handler(ld);
this->_loss_detector[index] = ld;
}
@@ -481,18 +479,6 @@ QUICNetVConnection::stream_manager()
}
void
-QUICNetVConnection::retransmit_packet(const QUICPacket &packet)
-{
- QUICConDebug("[NOP] Retransmit %s packet #%" PRIu64,
QUICDebugNames::packet_type(packet.type()), packet.packet_number());
-}
-
-Ptr<ProxyMutex>
-QUICNetVConnection::get_packet_transmitter_mutex()
-{
- return this->_packet_transmitter_mutex;
-}
-
-void
QUICNetVConnection::handle_received_packet(UDPPacket *packet)
{
this->_packet_recv_queue.enqueue(packet);
@@ -939,7 +925,6 @@
QUICNetVConnection::_state_handshake_process_version_negotiation_packet(QUICPack
this->_loss_detector[static_cast<int>(s)]->reset();
}
this->_congestion_controller->reset();
- SCOPED_MUTEX_LOCK(packet_transmitter_lock,
this->_packet_transmitter_mutex, this_ethread());
// start handshake over
this->_handshake_handler->reset();
@@ -1015,7 +1000,6 @@
QUICNetVConnection::_state_handshake_process_retry_packet(QUICPacketUPtr packet)
this->_loss_detector[static_cast<int>(s)]->reset();
}
this->_congestion_controller->reset();
- SCOPED_MUTEX_LOCK(packet_transmitter_lock, this->_packet_transmitter_mutex,
this_ethread());
this->_packet_recv_queue.reset();
// Initialize Key Materials with peer CID. Because peer CID is DCID of
(second) INITIAL packet from client which reply to RETRY
@@ -1324,7 +1308,6 @@ QUICNetVConnection::_packetize_frames(QUICEncryptionLevel
level, uint64_t max_pa
size_t len = 0;
ats_unique_buf buf = ats_unique_malloc(max_packet_size);
- SCOPED_MUTEX_LOCK(packet_transmitter_lock, this->_packet_transmitter_mutex,
this_ethread());
std::vector<QUICFrameInfo> frames;
if (!this->_has_ack_eliciting_packet_out) {
@@ -1420,8 +1403,6 @@ QUICNetVConnection::_packetize_frames(QUICEncryptionLevel
level, uint64_t max_pa
void
QUICNetVConnection::_packetize_closing_frame()
{
- SCOPED_MUTEX_LOCK(packet_transmitter_lock, this->_packet_transmitter_mutex,
this_ethread());
-
if (this->_connection_error == nullptr || this->_the_final_packet) {
return;
}
@@ -1638,7 +1619,6 @@
QUICNetVConnection::_dequeue_recv_packet(QUICPacketCreationResult &result)
void
QUICNetVConnection::_schedule_packet_write_ready(bool delay)
{
- SCOPED_MUTEX_LOCK(packet_transmitter_lock, this->_packet_transmitter_mutex,
this_ethread());
if (!this->_packet_write_ready) {
QUICConVVVDebug("Schedule %s event",
QUICDebugNames::quic_event(QUIC_EVENT_PACKET_WRITE_READY));
if (delay) {
@@ -1652,7 +1632,6 @@ QUICNetVConnection::_schedule_packet_write_ready(bool
delay)
void
QUICNetVConnection::_unschedule_packet_write_ready()
{
- SCOPED_MUTEX_LOCK(packet_transmitter_lock, this->_packet_transmitter_mutex,
this_ethread());
if (this->_packet_write_ready) {
this->_packet_write_ready->cancel();
this->_packet_write_ready = nullptr;
@@ -1662,7 +1641,6 @@ QUICNetVConnection::_unschedule_packet_write_ready()
void
QUICNetVConnection::_close_packet_write_ready(Event *data)
{
- SCOPED_MUTEX_LOCK(packet_transmitter_lock, this->_packet_transmitter_mutex,
this_ethread());
ink_assert(this->_packet_write_ready == data);
this->_packet_write_ready = nullptr;
}
diff --git a/iocore/net/quic/Mock.h b/iocore/net/quic/Mock.h
index bccd6d1..94c8c46 100644
--- a/iocore/net/quic/Mock.h
+++ b/iocore/net/quic/Mock.h
@@ -29,7 +29,6 @@
#include "QUICStreamManager.h"
#include "QUICLossDetector.h"
#include "QUICEvents.h"
-#include "QUICPacketTransmitter.h"
class MockQUICStreamManager : public QUICStreamManager
{
@@ -185,18 +184,6 @@ public:
return std::string_view("00000000-00000000"sv);
}
- void
- retransmit_packet(const QUICPacket &packet) override
- {
- ++_retransmit_count;
- }
-
- Ptr<ProxyMutex>
- get_packet_transmitter_mutex() override
- {
- return this->_mutex;
- }
-
std::vector<QUICFrameType>
interests() override
{
@@ -350,29 +337,6 @@ class MockQUICConnectionInfoProvider : public
QUICConnectionInfoProvider
}
};
-class MockQUICPacketTransmitter : public QUICPacketTransmitter
-{
-public:
- MockQUICPacketTransmitter() : QUICPacketTransmitter() { this->_mutex =
new_ProxyMutex(); };
-
- void
- retransmit_packet(const QUICPacket &packet) override
- {
- this->retransmitted.insert(packet.packet_number());
- }
-
- Ptr<ProxyMutex>
- get_packet_transmitter_mutex() override
- {
- return this->_mutex;
- }
-
- Ptr<ProxyMutex> _mutex;
-
- std::set<QUICPacketNumber> transmitted;
- std::set<QUICPacketNumber> retransmitted;
-};
-
class MockQUICCongestionController : public QUICCongestionController
{
public:
@@ -421,9 +385,8 @@ private:
class MockQUICLossDetector : public QUICLossDetector
{
public:
- MockQUICLossDetector(QUICPacketTransmitter *transmitter,
QUICConnectionInfoProvider *info, QUICCongestionController *cc,
- QUICRTTMeasure *rtt_measure, int index)
- : QUICLossDetector(transmitter, info, cc, rtt_measure, index)
+ MockQUICLossDetector(QUICConnectionInfoProvider *info,
QUICCongestionController *cc, QUICRTTMeasure *rtt_measure, int index)
+ : QUICLossDetector(info, cc, rtt_measure, index)
{
}
void
@@ -702,13 +665,14 @@ class MockQUICFrameGenerator : public QUICFrameGenerator
{
public:
bool
- will_generate_frame(QUICEncryptionLevel level) override
+ will_generate_frame(QUICEncryptionLevel level, ink_hrtime timestamp) override
{
return true;
}
QUICFrame *
- generate_frame(uint8_t *buf, QUICEncryptionLevel level, uint64_t
connection_credit, uint16_t maximum_frame_size) override
+ generate_frame(uint8_t *buf, QUICEncryptionLevel level, uint64_t
connection_credit, uint16_t maximum_frame_size,
+ ink_hrtime timestamp) override
{
QUICFrame *frame = QUICFrameFactory::create_ping_frame(buf,
0, this);
QUICFrameInformationUPtr info =
QUICFrameInformationUPtr(quicFrameInformationAllocator.alloc());
diff --git a/iocore/net/quic/QUICConnection.h b/iocore/net/quic/QUICConnection.h
index 96efe4f..36cc5fb 100644
--- a/iocore/net/quic/QUICConnection.h
+++ b/iocore/net/quic/QUICConnection.h
@@ -25,7 +25,6 @@
#include "I_EventSystem.h"
#include "I_NetVConnection.h"
-#include "QUICPacketTransmitter.h"
#include "QUICFrameHandler.h"
class QUICApplication;
@@ -50,7 +49,7 @@ public:
virtual std::string_view negotiated_application_name() const = 0;
};
-class QUICConnection : public QUICPacketTransmitter, public QUICFrameHandler,
public QUICConnectionInfoProvider
+class QUICConnection : public QUICFrameHandler, public
QUICConnectionInfoProvider
{
public:
virtual QUICStreamManager *stream_manager() = 0;
diff --git a/iocore/net/quic/QUICFrameHandler.h
b/iocore/net/quic/QUICFrameHandler.h
index 12c3fc9..5a2870f 100644
--- a/iocore/net/quic/QUICFrameHandler.h
+++ b/iocore/net/quic/QUICFrameHandler.h
@@ -24,6 +24,8 @@
#pragma once
#include <vector>
+#include "QUICTypes.h"
+
class QUICFrame;
class QUICFrameHandler
diff --git a/iocore/net/quic/QUICLossDetector.cc
b/iocore/net/quic/QUICLossDetector.cc
index d15287e..337d9e8 100644
--- a/iocore/net/quic/QUICLossDetector.cc
+++ b/iocore/net/quic/QUICLossDetector.cc
@@ -37,9 +37,9 @@
Debug("v_quic_loss_detector", "[%s] [%s] " fmt, this->_info->cids().data(),
QUICDebugNames::pn_space(this->_pn_space_index), \
##__VA_ARGS__)
-QUICLossDetector::QUICLossDetector(QUICPacketTransmitter *transmitter,
QUICConnectionInfoProvider *info,
- QUICCongestionController *cc,
QUICRTTMeasure *rtt_measure, int index)
- : _transmitter(transmitter), _info(info), _cc(cc),
_rtt_measure(rtt_measure), _pn_space_index(index)
+QUICLossDetector::QUICLossDetector(QUICConnectionInfoProvider *info,
QUICCongestionController *cc, QUICRTTMeasure *rtt_measure,
+ int index)
+ : _info(info), _cc(cc), _rtt_measure(rtt_measure), _pn_space_index(index)
{
this->mutex = new_ProxyMutex();
this->_loss_detection_mutex = new_ProxyMutex();
@@ -64,8 +64,7 @@ QUICLossDetector::~QUICLossDetector()
this->_sent_packets.clear();
- this->_transmitter = nullptr;
- this->_cc = nullptr;
+ this->_cc = nullptr;
}
int
@@ -202,7 +201,6 @@ QUICLossDetector::_on_packet_sent(QUICPacketNumber
packet_number, bool ack_elici
void
QUICLossDetector::_on_ack_received(const QUICAckFrame &ack_frame)
{
- SCOPED_MUTEX_LOCK(transmitter_lock,
this->_transmitter->get_packet_transmitter_mutex().get(), this_ethread());
SCOPED_MUTEX_LOCK(lock, this->_loss_detection_mutex, this_ethread());
this->_largest_acked_packet = std::max(this->_largest_acked_packet,
ack_frame.largest_acknowledged());
@@ -285,7 +283,6 @@ QUICLossDetector::_update_rtt(ink_hrtime latest_rtt,
ink_hrtime ack_delay)
void
QUICLossDetector::_on_packet_acked(const PacketInfo &acked_packet)
{
- SCOPED_MUTEX_LOCK(transmitter_lock,
this->_transmitter->get_packet_transmitter_mutex().get(), this_ethread());
SCOPED_MUTEX_LOCK(lock, this->_loss_detection_mutex, this_ethread());
// QUICLDDebug("Packet number %" PRIu64 " has been acked",
acked_packet_number);
@@ -395,7 +392,6 @@ QUICLossDetector::_on_loss_detection_timeout()
void
QUICLossDetector::_detect_lost_packets()
{
- SCOPED_MUTEX_LOCK(transmitter_lock,
this->_transmitter->get_packet_transmitter_mutex().get(), this_ethread());
SCOPED_MUTEX_LOCK(lock, this->_loss_detection_mutex, this_ethread());
this->_loss_time = 0;
ink_hrtime loss_delay = this->_k_time_threshold *
std::max(this->_latest_rtt, this->_smoothed_rtt);
@@ -458,7 +454,6 @@ QUICLossDetector::_detect_lost_packets()
void
QUICLossDetector::_retransmit_all_unacked_crypto_data()
{
- SCOPED_MUTEX_LOCK(transmitter_lock,
this->_transmitter->get_packet_transmitter_mutex().get(), this_ethread());
SCOPED_MUTEX_LOCK(lock, this->_loss_detection_mutex, this_ethread());
std::set<QUICPacketNumber> retransmitted_crypto_packets;
std::map<QUICPacketNumber, PacketInfo *> lost_packets;
@@ -480,7 +475,6 @@ QUICLossDetector::_retransmit_all_unacked_crypto_data()
void
QUICLossDetector::_send_two_packets()
{
- SCOPED_MUTEX_LOCK(transmitter_lock,
this->_transmitter->get_packet_transmitter_mutex().get(), this_ethread());
SCOPED_MUTEX_LOCK(lock, this->_loss_detection_mutex, this_ethread());
// TODO sent ping
}
@@ -490,7 +484,6 @@ QUICLossDetector::_send_two_packets()
void
QUICLossDetector::_retransmit_lost_packet(QUICPacketUPtr &packet)
{
- SCOPED_MUTEX_LOCK(transmitter_lock,
this->_transmitter->get_packet_transmitter_mutex().get(), this_ethread());
SCOPED_MUTEX_LOCK(lock, this->_loss_detection_mutex, this_ethread());
QUICLDDebug("[NOP] Retransmit %s packet #%" PRIu64,
QUICDebugNames::packet_type(packet->type()), packet->packet_number());
diff --git a/iocore/net/quic/QUICLossDetector.h
b/iocore/net/quic/QUICLossDetector.h
index 42a2102..8f69c95 100644
--- a/iocore/net/quic/QUICLossDetector.h
+++ b/iocore/net/quic/QUICLossDetector.h
@@ -35,7 +35,6 @@
#include "QUICPacket.h"
#include "QUICFrame.h"
#include "QUICFrameHandler.h"
-#include "QUICPacketTransmitter.h"
#include "QUICConnection.h"
class QUICLossDetector;
@@ -119,8 +118,7 @@ private:
class QUICLossDetector : public Continuation, public QUICFrameHandler
{
public:
- QUICLossDetector(QUICPacketTransmitter *transmitter,
QUICConnectionInfoProvider *info, QUICCongestionController *cc,
- QUICRTTMeasure *rtt_measure, int index);
+ QUICLossDetector(QUICConnectionInfoProvider *info, QUICCongestionController
*cc, QUICRTTMeasure *rtt_measure, int index);
~QUICLossDetector();
int event_handler(int event, Event *edata);
@@ -194,9 +192,8 @@ private:
void _send_one_packet();
void _send_two_packets();
- QUICPacketTransmitter *_transmitter = nullptr;
- QUICConnectionInfoProvider *_info = nullptr;
- QUICCongestionController *_cc = nullptr;
- QUICRTTMeasure *_rtt_measure = nullptr;
- int _pn_space_index = -1;
+ QUICConnectionInfoProvider *_info = nullptr;
+ QUICCongestionController *_cc = nullptr;
+ QUICRTTMeasure *_rtt_measure = nullptr;
+ int _pn_space_index = -1;
};
diff --git a/iocore/net/quic/QUICPacketTransmitter.h
b/iocore/net/quic/QUICPacketTransmitter.h
deleted file mode 100644
index c60e55c..0000000
--- a/iocore/net/quic/QUICPacketTransmitter.h
+++ /dev/null
@@ -1,44 +0,0 @@
-/** @file
- *
- * A brief file description
- *
- * @section license License
- *
- * Licensed to the Apache Software Foundation (ASF) under one
- * or more contributor license agreements. See the NOTICE file
- * distributed with this work for additional information
- * regarding copyright ownership. The ASF licenses this file
- * to you under the Apache License, Version 2.0 (the
- * "License"); you may not use this file except in compliance
- * with the License. You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-#pragma once
-
-#include "QUICPacket.h"
-#include "I_EventSystem.h"
-
-class QUICPacketTransmitter
-{
-public:
- /*
- * Enqueue a packet for retransmission
- * All frames except ACK and PADDING frames in the original packet will be
retransmitted on a new packet.
- * This sends QUIC_PACKET_WRITE_READY event.
- */
- virtual void retransmit_packet(const QUICPacket &packet) = 0;
-
- /*
- * Returns a mutex for transmitter interfaces.
- * You have to acquire a lock with this mutex before calling any methods
provieded by QUICPacketTransmitter
- */
- virtual Ptr<ProxyMutex> get_packet_transmitter_mutex() = 0;
-};
diff --git a/iocore/net/quic/test/test_QUICAckFrameCreator.cc
b/iocore/net/quic/test/test_QUICAckFrameCreator.cc
index 7e0d410..48fc90f 100644
--- a/iocore/net/quic/test/test_QUICAckFrameCreator.cc
+++ b/iocore/net/quic/test/test_QUICAckFrameCreator.cc
@@ -34,13 +34,13 @@ TEST_CASE("QUICAckFrameManager", "[quic]")
uint8_t frame_buf[QUICFrame::MAX_INSTANCE_SIZE];
// Initial state
- QUICFrame *ack_frame = ack_manager.generate_frame(frame_buf, level,
UINT16_MAX, UINT16_MAX);
+ QUICFrame *ack_frame = ack_manager.generate_frame(frame_buf, level,
UINT16_MAX, UINT16_MAX, 0);
QUICAckFrame *frame = static_cast<QUICAckFrame *>(ack_frame);
CHECK(frame == nullptr);
// One packet
ack_manager.update(level, 1, 1, false);
- ack_frame = ack_manager.generate_frame(frame_buf, level, UINT16_MAX,
UINT16_MAX);
+ ack_frame = ack_manager.generate_frame(frame_buf, level, UINT16_MAX,
UINT16_MAX, 0);
frame = static_cast<QUICAckFrame *>(ack_frame);
CHECK(frame != nullptr);
CHECK(frame->ack_block_count() == 0);
@@ -48,14 +48,14 @@ TEST_CASE("QUICAckFrameManager", "[quic]")
CHECK(frame->ack_block_section()->first_ack_block() == 0);
// retry
- CHECK(ack_manager.will_generate_frame(level) == false);
+ CHECK(ack_manager.will_generate_frame(level, 0) == false);
// Not sequential
ack_manager.update(level, 2, 1, false);
ack_manager.update(level, 5, 1, false);
ack_manager.update(level, 3, 1, false);
ack_manager.update(level, 4, 1, false);
- ack_frame = ack_manager.generate_frame(frame_buf, level, UINT16_MAX,
UINT16_MAX);
+ ack_frame = ack_manager.generate_frame(frame_buf, level, UINT16_MAX,
UINT16_MAX, 0);
frame = static_cast<QUICAckFrame *>(ack_frame);
CHECK(frame != nullptr);
CHECK(frame->ack_block_count() == 0);
@@ -66,7 +66,7 @@ TEST_CASE("QUICAckFrameManager", "[quic]")
ack_manager.update(level, 6, 1, false);
ack_manager.update(level, 7, 1, false);
ack_manager.update(level, 10, 1, false);
- ack_frame = ack_manager.generate_frame(frame_buf, level, UINT16_MAX,
UINT16_MAX);
+ ack_frame = ack_manager.generate_frame(frame_buf, level, UINT16_MAX,
UINT16_MAX, 0);
frame = static_cast<QUICAckFrame *>(ack_frame);
CHECK(frame != nullptr);
CHECK(frame->ack_block_count() == 1);
@@ -77,14 +77,14 @@ TEST_CASE("QUICAckFrameManager", "[quic]")
// on frame acked
ack_manager.on_frame_acked(frame->id());
- CHECK(ack_manager.will_generate_frame(level) == false);
- ack_frame = ack_manager.generate_frame(frame_buf, level, UINT16_MAX,
UINT16_MAX);
+ CHECK(ack_manager.will_generate_frame(level, 0) == false);
+ ack_frame = ack_manager.generate_frame(frame_buf, level, UINT16_MAX,
UINT16_MAX, 0);
CHECK(ack_frame == nullptr);
ack_manager.update(level, 11, 1, false);
ack_manager.update(level, 12, 1, false);
ack_manager.update(level, 13, 1, false);
- ack_frame = ack_manager.generate_frame(frame_buf, level, UINT16_MAX,
UINT16_MAX);
+ ack_frame = ack_manager.generate_frame(frame_buf, level, UINT16_MAX,
UINT16_MAX, 0);
frame = static_cast<QUICAckFrame *>(ack_frame);
CHECK(frame != nullptr);
CHECK(frame->ack_block_count() == 0);
@@ -98,11 +98,11 @@ TEST_CASE("QUICAckFrameManager", "[quic]")
ack_manager.update(level, 14, 1, true);
ack_manager.update(level, 15, 1, true);
ack_manager.update(level, 16, 1, true);
- CHECK(ack_manager.will_generate_frame(level) == false);
- ack_frame = ack_manager.generate_frame(frame_buf, level, UINT16_MAX,
UINT16_MAX);
+ CHECK(ack_manager.will_generate_frame(level, 0) == false);
+ ack_frame = ack_manager.generate_frame(frame_buf, level, UINT16_MAX,
UINT16_MAX, 0);
ack_manager.update(level, 17, 1, false);
- ack_frame = ack_manager.generate_frame(frame_buf, level, UINT16_MAX,
UINT16_MAX);
+ ack_frame = ack_manager.generate_frame(frame_buf, level, UINT16_MAX,
UINT16_MAX, 0);
frame = static_cast<QUICAckFrame *>(ack_frame);
CHECK(frame != nullptr);
CHECK(frame->ack_block_count() == 0);
@@ -119,7 +119,7 @@ TEST_CASE("QUICAckFrameManager should send", "[quic]")
QUICEncryptionLevel level = QUICEncryptionLevel::ONE_RTT;
ack_manager.update(level, 2, 1, false);
- CHECK(ack_manager.will_generate_frame(level) == true);
+ CHECK(ack_manager.will_generate_frame(level, 0) == true);
}
SECTION("QUIC delay ack and unorder packet", "[quic]")
@@ -128,13 +128,13 @@ TEST_CASE("QUICAckFrameManager should send", "[quic]")
QUICEncryptionLevel level = QUICEncryptionLevel::ONE_RTT;
ack_manager.update(level, 0, 1, false);
- CHECK(ack_manager.will_generate_frame(level) == false);
+ CHECK(ack_manager.will_generate_frame(level, 0) == false);
ack_manager.update(level, 1, 1, false);
- CHECK(ack_manager.will_generate_frame(level) == false);
+ CHECK(ack_manager.will_generate_frame(level, 0) == false);
ack_manager.update(level, 3, 1, false);
- CHECK(ack_manager.will_generate_frame(level) == true);
+ CHECK(ack_manager.will_generate_frame(level, 0) == true);
}
SECTION("QUIC delay too much time", "[quic]")
@@ -144,12 +144,12 @@ TEST_CASE("QUICAckFrameManager should send", "[quic]")
QUICEncryptionLevel level = QUICEncryptionLevel::ONE_RTT;
ack_manager.update(level, 0, 1, false);
- CHECK(ack_manager.will_generate_frame(level) == false);
+ CHECK(ack_manager.will_generate_frame(level, 0) == false);
sleep(1);
Thread::get_hrtime_updated();
ack_manager.update(level, 1, 1, false);
- CHECK(ack_manager.will_generate_frame(level) == true);
+ CHECK(ack_manager.will_generate_frame(level, 0) == true);
}
SECTION("QUIC intial packet", "[quic]")
@@ -158,7 +158,7 @@ TEST_CASE("QUICAckFrameManager should send", "[quic]")
QUICEncryptionLevel level = QUICEncryptionLevel::INITIAL;
ack_manager.update(level, 0, 1, false);
- CHECK(ack_manager.will_generate_frame(level) == true);
+ CHECK(ack_manager.will_generate_frame(level, 0) == true);
}
SECTION("QUIC handshake packet", "[quic]")
@@ -167,7 +167,7 @@ TEST_CASE("QUICAckFrameManager should send", "[quic]")
QUICEncryptionLevel level = QUICEncryptionLevel::HANDSHAKE;
ack_manager.update(level, 0, 1, false);
- CHECK(ack_manager.will_generate_frame(level) == true);
+ CHECK(ack_manager.will_generate_frame(level, 0) == true);
}
SECTION("QUIC frame fired", "[quic]")
@@ -176,11 +176,11 @@ TEST_CASE("QUICAckFrameManager should send", "[quic]")
QUICEncryptionLevel level = QUICEncryptionLevel::ONE_RTT;
ack_manager.update(level, 0, 1, false);
- CHECK(ack_manager.will_generate_frame(level) == false);
+ CHECK(ack_manager.will_generate_frame(level, 0) == false);
sleep(1);
Thread::get_hrtime_updated();
- CHECK(ack_manager.will_generate_frame(level) == true);
+ CHECK(ack_manager.will_generate_frame(level, 0) == true);
}
SECTION("QUIC refresh frame", "[quic]")
@@ -189,21 +189,21 @@ TEST_CASE("QUICAckFrameManager should send", "[quic]")
QUICEncryptionLevel level = QUICEncryptionLevel::ONE_RTT;
uint8_t frame_buf[QUICFrame::MAX_INSTANCE_SIZE];
- QUICFrame *ack_frame = ack_manager.generate_frame(frame_buf, level,
UINT16_MAX, UINT16_MAX);
+ QUICFrame *ack_frame = ack_manager.generate_frame(frame_buf, level,
UINT16_MAX, UINT16_MAX, 0);
QUICAckFrame *frame = static_cast<QUICAckFrame *>(ack_frame);
CHECK(frame == nullptr);
// unorder frame should sent immediately
ack_manager.update(level, 1, 1, false);
- CHECK(ack_manager.will_generate_frame(level) == true);
+ CHECK(ack_manager.will_generate_frame(level, 0) == true);
ack_manager.update(level, 2, 1, false);
// Delay due to some reason, the frame is not valued any more, but still
valued
sleep(1);
Thread::get_hrtime_updated();
- CHECK(ack_manager.will_generate_frame(level) == true);
- ack_frame = ack_manager.generate_frame(frame_buf, level, UINT16_MAX,
UINT16_MAX);
+ CHECK(ack_manager.will_generate_frame(level, 0) == true);
+ ack_frame = ack_manager.generate_frame(frame_buf, level, UINT16_MAX,
UINT16_MAX, 0);
frame = static_cast<QUICAckFrame *>(ack_frame);
CHECK(frame->ack_block_count() == 0);
@@ -220,7 +220,7 @@ TEST_CASE("QUICAckFrameManager_loss_recover", "[quic]")
// Initial state
uint8_t frame_buf[QUICFrame::MAX_INSTANCE_SIZE];
- QUICFrame *ack_frame = ack_manager.generate_frame(frame_buf, level,
UINT16_MAX, UINT16_MAX);
+ QUICFrame *ack_frame = ack_manager.generate_frame(frame_buf, level,
UINT16_MAX, UINT16_MAX, 0);
QUICAckFrame *frame = static_cast<QUICAckFrame *>(ack_frame);
CHECK(frame == nullptr);
@@ -230,7 +230,7 @@ TEST_CASE("QUICAckFrameManager_loss_recover", "[quic]")
ack_manager.update(level, 8, 1, false);
ack_manager.update(level, 9, 1, false);
- ack_frame = ack_manager.generate_frame(frame_buf, level, UINT16_MAX,
UINT16_MAX);
+ ack_frame = ack_manager.generate_frame(frame_buf, level, UINT16_MAX,
UINT16_MAX, 0);
frame = static_cast<QUICAckFrame *>(ack_frame);
CHECK(frame != nullptr);
CHECK(frame->ack_block_count() == 2);
@@ -238,11 +238,11 @@ TEST_CASE("QUICAckFrameManager_loss_recover", "[quic]")
CHECK(frame->ack_block_section()->first_ack_block() == 1);
CHECK(frame->ack_block_section()->begin()->gap() == 0);
- CHECK(ack_manager.will_generate_frame(level) == false);
+ CHECK(ack_manager.will_generate_frame(level, 0) == false);
ack_manager.update(level, 7, 1, false);
ack_manager.update(level, 4, 1, false);
- ack_frame = ack_manager.generate_frame(frame_buf, level, UINT16_MAX,
UINT16_MAX);
+ ack_frame = ack_manager.generate_frame(frame_buf, level, UINT16_MAX,
UINT16_MAX, 0);
frame = static_cast<QUICAckFrame *>(ack_frame);
CHECK(frame != nullptr);
CHECK(frame->ack_block_count() == 1);
@@ -299,7 +299,7 @@ TEST_CASE("QUICAckFrameManager lost_frame", "[quic]")
uint8_t frame_buf[QUICFrame::MAX_INSTANCE_SIZE];
// Initial state
- QUICFrame *ack_frame = ack_manager.generate_frame(frame_buf, level,
UINT16_MAX, UINT16_MAX);
+ QUICFrame *ack_frame = ack_manager.generate_frame(frame_buf, level,
UINT16_MAX, UINT16_MAX, 0);
QUICAckFrame *frame = static_cast<QUICAckFrame *>(ack_frame);
CHECK(frame == nullptr);
@@ -309,7 +309,7 @@ TEST_CASE("QUICAckFrameManager lost_frame", "[quic]")
ack_manager.update(level, 8, 1, false);
ack_manager.update(level, 9, 1, false);
- ack_frame = ack_manager.generate_frame(frame_buf, level, UINT16_MAX,
UINT16_MAX);
+ ack_frame = ack_manager.generate_frame(frame_buf, level, UINT16_MAX,
UINT16_MAX, 0);
frame = static_cast<QUICAckFrame *>(ack_frame);
CHECK(frame != nullptr);
CHECK(frame->ack_block_count() == 2);
@@ -318,8 +318,8 @@ TEST_CASE("QUICAckFrameManager lost_frame", "[quic]")
CHECK(frame->ack_block_section()->begin()->gap() == 0);
ack_manager.on_frame_lost(frame->id());
- CHECK(ack_manager.will_generate_frame(level) == true);
- ack_frame = ack_manager.generate_frame(frame_buf, level, UINT16_MAX,
UINT16_MAX);
+ CHECK(ack_manager.will_generate_frame(level, 0) == true);
+ ack_frame = ack_manager.generate_frame(frame_buf, level, UINT16_MAX,
UINT16_MAX, 0);
frame = static_cast<QUICAckFrame *>(ack_frame);
CHECK(frame != nullptr);
CHECK(frame->ack_block_count() == 2);
@@ -327,13 +327,13 @@ TEST_CASE("QUICAckFrameManager lost_frame", "[quic]")
CHECK(frame->ack_block_section()->first_ack_block() == 1);
CHECK(frame->ack_block_section()->begin()->gap() == 0);
- CHECK(ack_manager.will_generate_frame(level) == false);
+ CHECK(ack_manager.will_generate_frame(level, 0) == false);
ack_manager.on_frame_lost(frame->id());
- CHECK(ack_manager.will_generate_frame(level) == true);
+ CHECK(ack_manager.will_generate_frame(level, 0) == true);
ack_manager.update(level, 7, 1, false);
ack_manager.update(level, 4, 1, false);
- ack_frame = ack_manager.generate_frame(frame_buf, level, UINT16_MAX,
UINT16_MAX);
+ ack_frame = ack_manager.generate_frame(frame_buf, level, UINT16_MAX,
UINT16_MAX, 0);
frame = static_cast<QUICAckFrame *>(ack_frame);
CHECK(frame != nullptr);
CHECK(frame->ack_block_count() == 1);
@@ -341,7 +341,7 @@ TEST_CASE("QUICAckFrameManager lost_frame", "[quic]")
CHECK(frame->ack_block_section()->first_ack_block() == 5);
CHECK(frame->ack_block_section()->begin()->gap() == 0);
- CHECK(ack_manager.will_generate_frame(level) == false);
+ CHECK(ack_manager.will_generate_frame(level, 0) == false);
}
TEST_CASE("QUICAckFrameManager ack only packet", "[quic]")
@@ -353,7 +353,7 @@ TEST_CASE("QUICAckFrameManager ack only packet", "[quic]")
uint8_t frame_buf[QUICFrame::MAX_INSTANCE_SIZE];
// Initial state
- QUICFrame *ack_frame = ack_manager.generate_frame(frame_buf, level,
UINT16_MAX, UINT16_MAX);
+ QUICFrame *ack_frame = ack_manager.generate_frame(frame_buf, level,
UINT16_MAX, UINT16_MAX, 0);
QUICAckFrame *frame = static_cast<QUICAckFrame *>(ack_frame);
CHECK(frame == nullptr);
@@ -363,9 +363,9 @@ TEST_CASE("QUICAckFrameManager ack only packet", "[quic]")
ack_manager.update(level, 4, 1, false);
ack_manager.update(level, 5, 1, false);
- CHECK(ack_manager.will_generate_frame(level) == true);
+ CHECK(ack_manager.will_generate_frame(level, 0) == true);
- ack_frame = ack_manager.generate_frame(frame_buf, level, UINT16_MAX,
UINT16_MAX);
+ ack_frame = ack_manager.generate_frame(frame_buf, level, UINT16_MAX,
UINT16_MAX, 0);
frame = static_cast<QUICAckFrame *>(ack_frame);
CHECK(frame != nullptr);
CHECK(frame->ack_block_count() == 0);
@@ -375,7 +375,7 @@ TEST_CASE("QUICAckFrameManager ack only packet", "[quic]")
ack_manager.update(level, 6, 1, true);
ack_manager.update(level, 7, 1, true);
- CHECK(ack_manager.will_generate_frame(level) == false);
+ CHECK(ack_manager.will_generate_frame(level, 0) == false);
}
SECTION("ONE_RTT")
@@ -385,7 +385,7 @@ TEST_CASE("QUICAckFrameManager ack only packet", "[quic]")
uint8_t frame_buf[QUICFrame::MAX_INSTANCE_SIZE];
// Initial state
- QUICFrame *ack_frame = ack_manager.generate_frame(frame_buf, level,
UINT16_MAX, UINT16_MAX);
+ QUICFrame *ack_frame = ack_manager.generate_frame(frame_buf, level,
UINT16_MAX, UINT16_MAX, 0);
QUICAckFrame *frame = static_cast<QUICAckFrame *>(ack_frame);
CHECK(frame == nullptr);
@@ -395,9 +395,9 @@ TEST_CASE("QUICAckFrameManager ack only packet", "[quic]")
ack_manager.update(level, 4, 1, false);
ack_manager.update(level, 5, 1, false);
- CHECK(ack_manager.will_generate_frame(level) == true);
+ CHECK(ack_manager.will_generate_frame(level, 0) == true);
- ack_frame = ack_manager.generate_frame(frame_buf, level, UINT16_MAX,
UINT16_MAX);
+ ack_frame = ack_manager.generate_frame(frame_buf, level, UINT16_MAX,
UINT16_MAX, 0);
frame = static_cast<QUICAckFrame *>(ack_frame);
CHECK(frame != nullptr);
CHECK(frame->ack_block_count() == 0);
@@ -407,6 +407,6 @@ TEST_CASE("QUICAckFrameManager ack only packet", "[quic]")
ack_manager.update(level, 6, 1, true);
ack_manager.update(level, 7, 1, true);
- CHECK(ack_manager.will_generate_frame(level) == false);
+ CHECK(ack_manager.will_generate_frame(level, 0) == false);
}
}
diff --git a/iocore/net/quic/test/test_QUICFlowController.cc
b/iocore/net/quic/test/test_QUICFlowController.cc
index 8333560..a5120b1 100644
--- a/iocore/net/quic/test/test_QUICFlowController.cc
+++ b/iocore/net/quic/test/test_QUICFlowController.cc
@@ -98,7 +98,7 @@ TEST_CASE("QUICFlowController_Local_Connection", "[quic]")
fc.forward_limit(2048);
CHECK(fc.current_offset() == 1024);
CHECK(fc.current_limit() == 2048);
- QUICFrame *frame = fc.generate_frame(frame_buf,
QUICEncryptionLevel::ONE_RTT, 0, 1024);
+ QUICFrame *frame = fc.generate_frame(frame_buf,
QUICEncryptionLevel::ONE_RTT, 0, 1024, 0);
CHECK(frame);
CHECK(frame->type() == QUICFrameType::MAX_DATA);
@@ -150,7 +150,7 @@ TEST_CASE("QUICFlowController_Remote_Connection", "[quic]")
CHECK(fc.current_offset() == 1000);
CHECK(fc.current_limit() == 1024);
CHECK(ret != 0);
- QUICFrame *frame = fc.generate_frame(frame_buf,
QUICEncryptionLevel::ONE_RTT, 0, 1024);
+ QUICFrame *frame = fc.generate_frame(frame_buf,
QUICEncryptionLevel::ONE_RTT, 0, 1024, 0);
CHECK(frame);
CHECK(frame->type() == QUICFrameType::DATA_BLOCKED);
@@ -181,9 +181,9 @@
TEST_CASE("QUICFlowController_Remote_Connection_ZERO_Credit", "[quic]")
CHECK(fc.current_limit() == 1024);
CHECK(ret == 0);
- CHECK(fc.will_generate_frame(QUICEncryptionLevel::ONE_RTT));
+ CHECK(fc.will_generate_frame(QUICEncryptionLevel::ONE_RTT, 0));
// if there're anything to send
- QUICFrame *frame = fc.generate_frame(frame_buf,
QUICEncryptionLevel::ONE_RTT, 0, 1024);
+ QUICFrame *frame = fc.generate_frame(frame_buf,
QUICEncryptionLevel::ONE_RTT, 0, 1024, 0);
CHECK(frame);
CHECK(frame->type() == QUICFrameType::DATA_BLOCKED);
@@ -247,7 +247,7 @@ TEST_CASE("QUICFlowController_Local_Stream", "[quic]")
fc.forward_limit(2048);
CHECK(fc.current_offset() == 1024);
CHECK(fc.current_limit() == 2048);
- QUICFrame *frame = fc.generate_frame(frame_buf,
QUICEncryptionLevel::ONE_RTT, 0, 1024);
+ QUICFrame *frame = fc.generate_frame(frame_buf,
QUICEncryptionLevel::ONE_RTT, 0, 1024, 0);
CHECK(frame);
CHECK(frame->type() == QUICFrameType::MAX_STREAM_DATA);
@@ -288,7 +288,7 @@ TEST_CASE("QUICFlowController_Remote_Stream", "[quic]")
CHECK(ret == 0);
CHECK(fc.credit() == 0);
- CHECK(fc.will_generate_frame(QUICEncryptionLevel::ONE_RTT));
+ CHECK(fc.will_generate_frame(QUICEncryptionLevel::ONE_RTT, 0));
// Delay
ret = fc.update(512);
@@ -324,23 +324,23 @@ TEST_CASE("Frame retransmission", "[quic]")
QUICRemoteConnectionFlowController fc(1024);
// Check initial state
- auto frame = fc.generate_frame(frame_buf, level, 1024, 1024);
+ auto frame = fc.generate_frame(frame_buf, level, 1024, 1024, 0);
CHECK(!frame);
ret = fc.update(1024);
CHECK(ret == 0);
- frame = fc.generate_frame(frame_buf, level, 1024, 1024);
+ frame = fc.generate_frame(frame_buf, level, 1024, 1024, 0);
REQUIRE(frame);
CHECK(static_cast<QUICDataBlockedFrame *>(frame)->offset() == 1024);
QUICFrameId id = frame->id();
// Don't retransmit unless the frame is lost
- frame = fc.generate_frame(frame_buf, level, 1024, 1024);
+ frame = fc.generate_frame(frame_buf, level, 1024, 1024, 0);
REQUIRE(!frame);
// Retransmit
fc.on_frame_lost(id);
- frame = fc.generate_frame(frame_buf, level, 1024, 1024);
+ frame = fc.generate_frame(frame_buf, level, 1024, 1024, 0);
REQUIRE(frame);
CHECK(static_cast<QUICDataBlockedFrame *>(frame)->offset() == 1024);
@@ -348,12 +348,12 @@ TEST_CASE("Frame retransmission", "[quic]")
fc.on_frame_lost(frame->id());
fc.forward_limit(2048);
ret = fc.update(1536);
- frame = fc.generate_frame(frame_buf, level, 1024, 1024);
+ frame = fc.generate_frame(frame_buf, level, 1024, 1024, 0);
CHECK(!frame);
// This should not be retransmition
ret = fc.update(2048);
- frame = fc.generate_frame(frame_buf, level, 1024, 1024);
+ frame = fc.generate_frame(frame_buf, level, 1024, 1024, 0);
REQUIRE(frame);
CHECK(static_cast<QUICDataBlockedFrame *>(frame)->offset() == 2048);
}
@@ -365,23 +365,23 @@ TEST_CASE("Frame retransmission", "[quic]")
QUICRemoteStreamFlowController fc(1024, 0);
// Check initial state
- auto frame = fc.generate_frame(frame_buf, level, 1024, 1024);
+ auto frame = fc.generate_frame(frame_buf, level, 1024, 1024, 0);
CHECK(!frame);
ret = fc.update(1024);
CHECK(ret == 0);
- frame = fc.generate_frame(frame_buf, level, 1024, 1024);
+ frame = fc.generate_frame(frame_buf, level, 1024, 1024, 0);
REQUIRE(frame);
CHECK(static_cast<QUICStreamDataBlockedFrame *>(frame)->offset() == 1024);
QUICFrameId id = frame->id();
// Don't retransmit unless the frame is lost
- frame = fc.generate_frame(frame_buf, level, 1024, 1024);
+ frame = fc.generate_frame(frame_buf, level, 1024, 1024, 0);
REQUIRE(!frame);
// Retransmit
fc.on_frame_lost(id);
- frame = fc.generate_frame(frame_buf, level, 1024, 1024);
+ frame = fc.generate_frame(frame_buf, level, 1024, 1024, 0);
REQUIRE(frame);
CHECK(static_cast<QUICStreamDataBlockedFrame *>(frame)->offset() == 1024);
@@ -389,12 +389,12 @@ TEST_CASE("Frame retransmission", "[quic]")
fc.on_frame_lost(frame->id());
fc.forward_limit(2048);
ret = fc.update(1536);
- frame = fc.generate_frame(frame_buf, level, 1024, 1024);
+ frame = fc.generate_frame(frame_buf, level, 1024, 1024, 0);
CHECK(!frame);
// This should not be retransmition
ret = fc.update(2048);
- frame = fc.generate_frame(frame_buf, level, 1024, 1024);
+ frame = fc.generate_frame(frame_buf, level, 1024, 1024, 0);
REQUIRE(frame);
CHECK(static_cast<QUICStreamDataBlockedFrame *>(frame)->offset() == 2048);
}
@@ -407,23 +407,23 @@ TEST_CASE("Frame retransmission", "[quic]")
QUICLocalConnectionFlowController fc(&rp, 1024);
// Check initial state
- auto frame = fc.generate_frame(frame_buf, level, 1024, 1024);
+ auto frame = fc.generate_frame(frame_buf, level, 1024, 1024, 0);
CHECK(!frame);
fc.update(1024);
fc.forward_limit(1024);
- frame = fc.generate_frame(frame_buf, level, 1024, 1024);
+ frame = fc.generate_frame(frame_buf, level, 1024, 1024, 0);
REQUIRE(frame);
CHECK(static_cast<QUICMaxDataFrame *>(frame)->maximum_data() == 1024);
QUICFrameId id = frame->id();
// Don't retransmit unless the frame is lost
- frame = fc.generate_frame(frame_buf, level, 1024, 1024);
+ frame = fc.generate_frame(frame_buf, level, 1024, 1024, 0);
REQUIRE(!frame);
// Retransmit
fc.on_frame_lost(id);
- frame = fc.generate_frame(frame_buf, level, 1024, 1024);
+ frame = fc.generate_frame(frame_buf, level, 1024, 1024, 0);
REQUIRE(frame);
CHECK(static_cast<QUICMaxDataFrame *>(frame)->maximum_data() == 1024);
@@ -431,7 +431,7 @@ TEST_CASE("Frame retransmission", "[quic]")
fc.on_frame_lost(id);
fc.forward_limit(2048);
fc.update(2048);
- frame = fc.generate_frame(frame_buf, level, 1024, 1024);
+ frame = fc.generate_frame(frame_buf, level, 1024, 1024, 0);
REQUIRE(frame);
CHECK(static_cast<QUICMaxDataFrame *>(frame)->maximum_data() == 2048);
}
@@ -444,23 +444,23 @@ TEST_CASE("Frame retransmission", "[quic]")
QUICLocalStreamFlowController fc(&rp, 1024, 0);
// Check initial state
- auto frame = fc.generate_frame(frame_buf, level, 1024, 1024);
+ auto frame = fc.generate_frame(frame_buf, level, 1024, 1024, 0);
CHECK(!frame);
fc.update(1024);
fc.forward_limit(1024);
- frame = fc.generate_frame(frame_buf, level, 1024, 1024);
+ frame = fc.generate_frame(frame_buf, level, 1024, 1024, 0);
REQUIRE(frame);
CHECK(static_cast<QUICMaxStreamDataFrame *>(frame)->maximum_stream_data()
== 1024);
QUICFrameId id = frame->id();
// Don't retransmit unless the frame is lost
- frame = fc.generate_frame(frame_buf, level, 1024, 1024);
+ frame = fc.generate_frame(frame_buf, level, 1024, 1024, 0);
REQUIRE(!frame);
// Retransmit
fc.on_frame_lost(id);
- frame = fc.generate_frame(frame_buf, level, 1024, 1024);
+ frame = fc.generate_frame(frame_buf, level, 1024, 1024, 0);
REQUIRE(frame);
CHECK(static_cast<QUICMaxStreamDataFrame *>(frame)->maximum_stream_data()
== 1024);
@@ -468,7 +468,7 @@ TEST_CASE("Frame retransmission", "[quic]")
fc.on_frame_lost(id);
fc.forward_limit(2048);
fc.update(2048);
- frame = fc.generate_frame(frame_buf, level, 1024, 1024);
+ frame = fc.generate_frame(frame_buf, level, 1024, 1024, 0);
REQUIRE(frame);
CHECK(static_cast<QUICMaxStreamDataFrame *>(frame)->maximum_stream_data()
== 2048);
}
diff --git a/iocore/net/quic/test/test_QUICFrameDispatcher.cc
b/iocore/net/quic/test/test_QUICFrameDispatcher.cc
index 501eaa9..9f76b64 100644
--- a/iocore/net/quic/test/test_QUICFrameDispatcher.cc
+++ b/iocore/net/quic/test/test_QUICFrameDispatcher.cc
@@ -38,11 +38,10 @@ TEST_CASE("QUICFrameHandler", "[quic]")
MockQUICConnection connection;
MockQUICStreamManager streamManager;
- MockQUICPacketTransmitter tx;
MockQUICConnectionInfoProvider info;
MockQUICCongestionController cc(&info);
QUICRTTMeasure rtt_measure;
- MockQUICLossDetector lossDetector(&tx, &info, &cc, &rtt_measure, 0);
+ MockQUICLossDetector lossDetector(&info, &cc, &rtt_measure, 0);
QUICFrameDispatcher quicFrameDispatcher(&info);
quicFrameDispatcher.add_handler(&connection);
diff --git a/iocore/net/quic/test/test_QUICLossDetector.cc
b/iocore/net/quic/test/test_QUICLossDetector.cc
index bbdc59f..2074883 100644
--- a/iocore/net/quic/test/test_QUICLossDetector.cc
+++ b/iocore/net/quic/test/test_QUICLossDetector.cc
@@ -36,10 +36,9 @@ TEST_CASE("QUICLossDetector_Loss", "[quic]")
QUICAckFrameManager afm;
QUICConnectionId connection_id = {reinterpret_cast<const uint8_t *>("\x01"),
1};
- MockQUICPacketTransmitter tx;
MockQUICConnectionInfoProvider info;
MockQUICCongestionController cc(&info);
- QUICLossDetector detector(&tx, &info, &cc, &rtt_measure, 0);
+ QUICLossDetector detector(&info, &cc, &rtt_measure, 0);
ats_unique_buf payload = ats_unique_malloc(512);
size_t payload_len = 512;
QUICPacketUPtr packet = QUICPacketFactory::create_null_packet();
@@ -52,7 +51,7 @@ TEST_CASE("QUICLossDetector_Loss", "[quic]")
// Check initial state
uint8_t frame_buffer[1024] = {0};
CHECK(g.lost_frame_count == 0);
- QUICFrame *ping_frame = g.generate_frame(frame_buffer,
QUICEncryptionLevel::HANDSHAKE, 4, UINT16_MAX);
+ QUICFrame *ping_frame = g.generate_frame(frame_buffer,
QUICEncryptionLevel::HANDSHAKE, 4, UINT16_MAX, 0);
uint8_t raw[4];
size_t len;
@@ -85,9 +84,6 @@ TEST_CASE("QUICLossDetector_Loss", "[quic]")
SECTION("1-RTT")
{
- // Check initial state
- CHECK(tx.retransmitted.size() == 0);
-
// Send packet (1) to (7)
payload = ats_unique_malloc(payload_len);
QUICPacketUPtr packet1 = pf.create_protected_packet(connection_id,
detector.largest_acked_packet_number(), std::move(payload),
@@ -152,7 +148,7 @@ TEST_CASE("QUICLossDetector_Loss", "[quic]")
afm.update(QUICEncryptionLevel::INITIAL, pn9, payload_len, false);
afm.update(QUICEncryptionLevel::INITIAL, pn10, payload_len, false);
uint8_t buf[QUICFrame::MAX_INSTANCE_SIZE];
- QUICFrame *x = afm.generate_frame(buf, QUICEncryptionLevel::INITIAL, 2048,
2048);
+ QUICFrame *x = afm.generate_frame(buf, QUICEncryptionLevel::INITIAL, 2048,
2048, 0);
frame = static_cast<QUICAckFrame *>(x);
ink_hrtime_sleep(HRTIME_MSECONDS(1000));
detector.handle_frame(QUICEncryptionLevel::INITIAL, *frame);
@@ -176,14 +172,10 @@ TEST_CASE("QUICLossDetector_Loss", "[quic]")
TEST_CASE("QUICLossDetector_HugeGap", "[quic]")
{
uint8_t frame_buf[QUICFrame::MAX_INSTANCE_SIZE];
- MockQUICPacketTransmitter tx;
MockQUICConnectionInfoProvider info;
MockQUICCongestionController cc(&info);
QUICRTTMeasure rtt_measure;
- QUICLossDetector detector(&tx, &info, &cc, &rtt_measure, 0);
-
- // Check initial state
- CHECK(tx.retransmitted.size() == 0);
+ QUICLossDetector detector(&info, &cc, &rtt_measure, 0);
auto t1 = Thread::get_hrtime();
QUICAckFrame *ack = QUICFrameFactory::create_ack_frame(frame_buf, 100000000,
100, 10000000);
diff --git a/iocore/net/quic/test/test_QUICStream.cc
b/iocore/net/quic/test/test_QUICStream.cc
index bf6aadc..e18eaf1 100644
--- a/iocore/net/quic/test/test_QUICStream.cc
+++ b/iocore/net/quic/test/test_QUICStream.cc
@@ -223,50 +223,50 @@ TEST_CASE("QUICStream", "[quic]")
write_buffer->write(data, 1024);
stream->handleEvent(VC_EVENT_WRITE_READY, nullptr);
- CHECK(stream->will_generate_frame(level) == true);
- frame = stream->generate_frame(frame_buf, level, 4096, 4096);
+ CHECK(stream->will_generate_frame(level, 0) == true);
+ frame = stream->generate_frame(frame_buf, level, 4096, 4096, 0);
CHECK(frame->type() == QUICFrameType::STREAM);
- CHECK(stream->will_generate_frame(level) == false);
+ CHECK(stream->will_generate_frame(level, 0) == false);
write_buffer->write(data, 1024);
stream->handleEvent(VC_EVENT_WRITE_READY, nullptr);
- CHECK(stream->will_generate_frame(level) == true);
- frame = stream->generate_frame(frame_buf, level, 4096, 4096);
+ CHECK(stream->will_generate_frame(level, 0) == true);
+ frame = stream->generate_frame(frame_buf, level, 4096, 4096, 0);
CHECK(frame->type() == QUICFrameType::STREAM);
- CHECK(stream->will_generate_frame(level) == false);
+ CHECK(stream->will_generate_frame(level, 0) == false);
write_buffer->write(data, 1024);
stream->handleEvent(VC_EVENT_WRITE_READY, nullptr);
- CHECK(stream->will_generate_frame(level) == true);
- frame = stream->generate_frame(frame_buf, level, 4096, 4096);
+ CHECK(stream->will_generate_frame(level, 0) == true);
+ frame = stream->generate_frame(frame_buf, level, 4096, 4096, 0);
CHECK(frame->type() == QUICFrameType::STREAM);
- CHECK(stream->will_generate_frame(level) == false);
+ CHECK(stream->will_generate_frame(level, 0) == false);
write_buffer->write(data, 1024);
stream->handleEvent(VC_EVENT_WRITE_READY, nullptr);
- CHECK(stream->will_generate_frame(level) == true);
- frame = stream->generate_frame(frame_buf, level, 4096, 4096);
+ CHECK(stream->will_generate_frame(level, 0) == true);
+ frame = stream->generate_frame(frame_buf, level, 4096, 4096, 0);
CHECK(frame->type() == QUICFrameType::STREAM);
- CHECK(stream->will_generate_frame(level) == false);
+ CHECK(stream->will_generate_frame(level, 0) == false);
// This should not send a frame because of flow control
write_buffer->write(data, 1024);
stream->handleEvent(VC_EVENT_WRITE_READY, nullptr);
- CHECK(stream->will_generate_frame(level) == true);
- frame = stream->generate_frame(frame_buf, level, 4096, 4096);
+ CHECK(stream->will_generate_frame(level, 0) == true);
+ frame = stream->generate_frame(frame_buf, level, 4096, 4096, 0);
CHECK(frame);
CHECK(frame->type() == QUICFrameType::STREAM_DATA_BLOCKED);
- CHECK(stream->will_generate_frame(level) == true);
+ CHECK(stream->will_generate_frame(level, 0) == true);
// Update window
stream->recv(*std::make_shared<QUICMaxStreamDataFrame>(stream_id, 5120));
// This should send a frame
stream->handleEvent(VC_EVENT_WRITE_READY, nullptr);
- CHECK(stream->will_generate_frame(level) == true);
- frame = stream->generate_frame(frame_buf, level, 4096, 4096);
+ CHECK(stream->will_generate_frame(level, 0) == true);
+ frame = stream->generate_frame(frame_buf, level, 4096, 4096, 0);
CHECK(frame->type() == QUICFrameType::STREAM);
- CHECK(stream->will_generate_frame(level) == false);
+ CHECK(stream->will_generate_frame(level, 0) == false);
// Update window
stream->recv(*std::make_shared<QUICMaxStreamDataFrame>(stream_id, 5632));
@@ -274,24 +274,24 @@ TEST_CASE("QUICStream", "[quic]")
// This should send a frame
write_buffer->write(data, 1024);
stream->handleEvent(VC_EVENT_WRITE_READY, nullptr);
- CHECK(stream->will_generate_frame(level) == true);
- frame = stream->generate_frame(frame_buf, level, 4096, 4096);
+ CHECK(stream->will_generate_frame(level, 0) == true);
+ frame = stream->generate_frame(frame_buf, level, 4096, 4096, 0);
CHECK(frame->type() == QUICFrameType::STREAM);
- CHECK(stream->will_generate_frame(level) == true);
+ CHECK(stream->will_generate_frame(level, 0) == true);
stream->handleEvent(VC_EVENT_WRITE_READY, nullptr);
- CHECK(stream->will_generate_frame(level) == true);
- frame = stream->generate_frame(frame_buf, level, 4096, 4096);
+ CHECK(stream->will_generate_frame(level, 0) == true);
+ frame = stream->generate_frame(frame_buf, level, 4096, 4096, 0);
CHECK(frame->type() == QUICFrameType::STREAM_DATA_BLOCKED);
// Update window
stream->recv(*std::make_shared<QUICMaxStreamDataFrame>(stream_id, 6144));
stream->handleEvent(VC_EVENT_WRITE_READY, nullptr);
- CHECK(stream->will_generate_frame(level) == true);
- frame = stream->generate_frame(frame_buf, level, 4096, 4096);
+ CHECK(stream->will_generate_frame(level, 0) == true);
+ frame = stream->generate_frame(frame_buf, level, 4096, 4096, 0);
CHECK(frame->type() == QUICFrameType::STREAM);
- CHECK(stream->will_generate_frame(level) == false);
+ CHECK(stream->will_generate_frame(level, 0) == false);
}
/*
@@ -357,15 +357,15 @@ TEST_CASE("QUICStream", "[quic]")
QUICFrame *frame = nullptr;
stream->reset(QUICStreamErrorUPtr(new QUICStreamError(stream.get(),
QUIC_APP_ERROR_CODE_STOPPING)));
- frame = stream->generate_frame(frame_buf, level, 4096, 4096);
+ frame = stream->generate_frame(frame_buf, level, 4096, 4096, 0);
REQUIRE(frame);
CHECK(frame->type() == QUICFrameType::RESET_STREAM);
// Don't send it again untill it is considers as lost
- CHECK(stream->generate_frame(frame_buf, level, 4096, 4096) == nullptr);
+ CHECK(stream->generate_frame(frame_buf, level, 4096, 4096, 0) == nullptr);
// Loss the frame
stream->on_frame_lost(frame->id());
// After the loss the frame should be regenerated
- frame = stream->generate_frame(frame_buf, level, 4096, 4096);
+ frame = stream->generate_frame(frame_buf, level, 4096, 4096, 0);
REQUIRE(frame);
CHECK(frame->type() == QUICFrameType::RESET_STREAM);
}
@@ -387,15 +387,15 @@ TEST_CASE("QUICStream", "[quic]")
QUICFrame *frame = nullptr;
stream->stop_sending(QUICStreamErrorUPtr(new QUICStreamError(stream.get(),
QUIC_APP_ERROR_CODE_STOPPING)));
- frame = stream->generate_frame(frame_buf, level, 4096, 4096);
+ frame = stream->generate_frame(frame_buf, level, 4096, 4096, 0);
REQUIRE(frame);
CHECK(frame->type() == QUICFrameType::STOP_SENDING);
// Don't send it again untill it is considers as lost
- CHECK(stream->generate_frame(frame_buf, level, 4096, 4096) == nullptr);
+ CHECK(stream->generate_frame(frame_buf, level, 4096, 4096, 0) == nullptr);
// Loss the frame
stream->on_frame_lost(frame->id());
// After the loss the frame should be regenerated
- frame = stream->generate_frame(frame_buf, level, 4096, 4096);
+ frame = stream->generate_frame(frame_buf, level, 4096, 4096, 0);
REQUIRE(frame);
CHECK(frame->type() == QUICFrameType::STOP_SENDING);
}
