QuicTag QuicVersionToQuicTag(const QuicVersion version) {
switch (version) {
- case QUIC_VERSION_15:
- return MakeQuicTag('Q', '0', '1', '5');
case QUIC_VERSION_16:
return MakeQuicTag('Q', '0', '1', '6');
- case QUIC_VERSION_17:
- return MakeQuicTag('Q', '0', '1', '7');
case QUIC_VERSION_18:
return MakeQuicTag('Q', '0', '1', '8');
case QUIC_VERSION_19:
return MakeQuicTag('Q', '0', '1', '9');
case QUIC_VERSION_20:
return MakeQuicTag('Q', '0', '2', '0');
+ case QUIC_VERSION_21:
+ return MakeQuicTag('Q', '0', '2', '1');
+ case QUIC_VERSION_22:
+ return MakeQuicTag('Q', '0', '2', '2');
default:
// This shold be an ERROR because we should never attempt to convert an
// invalid QuicVersion to be written to the wire.
string QuicVersionToString(const QuicVersion version) {
switch (version) {
- RETURN_STRING_LITERAL(QUIC_VERSION_15);
RETURN_STRING_LITERAL(QUIC_VERSION_16);
- RETURN_STRING_LITERAL(QUIC_VERSION_17);
RETURN_STRING_LITERAL(QUIC_VERSION_18);
RETURN_STRING_LITERAL(QUIC_VERSION_19);
RETURN_STRING_LITERAL(QUIC_VERSION_20);
+ RETURN_STRING_LITERAL(QUIC_VERSION_21);
+ RETURN_STRING_LITERAL(QUIC_VERSION_22);
default:
return "QUIC_VERSION_UNSUPPORTED";
}
return os;
}
-ReceivedPacketInfo::ReceivedPacketInfo()
- : entropy_hash(0),
- largest_observed(0),
- delta_time_largest_observed(QuicTime::Delta::Infinite()),
- is_truncated(false) {}
-
-ReceivedPacketInfo::~ReceivedPacketInfo() {}
-
-bool IsAwaitingPacket(const ReceivedPacketInfo& received_info,
+bool IsAwaitingPacket(const QuicAckFrame& ack_frame,
QuicPacketSequenceNumber sequence_number) {
- return sequence_number > received_info.largest_observed ||
- ContainsKey(received_info.missing_packets, sequence_number);
+ return sequence_number > ack_frame.largest_observed ||
+ ContainsKey(ack_frame.missing_packets, sequence_number);
}
-void InsertMissingPacketsBetween(ReceivedPacketInfo* received_info,
+void InsertMissingPacketsBetween(QuicAckFrame* ack_frame,
QuicPacketSequenceNumber lower,
QuicPacketSequenceNumber higher) {
for (QuicPacketSequenceNumber i = lower; i < higher; ++i) {
- received_info->missing_packets.insert(i);
+ ack_frame->missing_packets.insert(i);
}
}
QuicStopWaitingFrame::~QuicStopWaitingFrame() {}
-QuicAckFrame::QuicAckFrame() {}
+QuicAckFrame::QuicAckFrame()
+ : entropy_hash(0),
+ largest_observed(0),
+ delta_time_largest_observed(QuicTime::Delta::Infinite()),
+ is_truncated(false) {}
+
+QuicAckFrame::~QuicAckFrame() {}
CongestionFeedbackMessageTCP::CongestionFeedbackMessageTCP()
: receive_window(0) {
}
-CongestionFeedbackMessageInterArrival::CongestionFeedbackMessageInterArrival() {
+CongestionFeedbackMessageTimestamp::CongestionFeedbackMessageTimestamp() {
}
-CongestionFeedbackMessageInterArrival::
- ~CongestionFeedbackMessageInterArrival() {}
+CongestionFeedbackMessageTimestamp::~CongestionFeedbackMessageTimestamp() {}
QuicCongestionFeedbackFrame::QuicCongestionFeedbackFrame() : type(kTCP) {}
QuicVersion version) {
switch (error_code) {
case QUIC_RST_FLOW_CONTROL_ACCOUNTING:
- if (version <= QUIC_VERSION_17) {
+ if (version < QUIC_VERSION_18) {
return QUIC_STREAM_NO_ERROR;
}
break;
return os;
}
-ostream& operator<<(ostream& os, const ReceivedPacketInfo& received_info) {
- os << "entropy_hash: " << static_cast<int>(received_info.entropy_hash)
- << " is_truncated: " << received_info.is_truncated
- << " largest_observed: " << received_info.largest_observed
+ostream& operator<<(ostream& os, const QuicAckFrame& ack_frame) {
+ os << "entropy_hash: " << static_cast<int>(ack_frame.entropy_hash)
+ << " is_truncated: " << ack_frame.is_truncated
+ << " largest_observed: " << ack_frame.largest_observed
<< " delta_time_largest_observed: "
- << received_info.delta_time_largest_observed.ToMicroseconds()
+ << ack_frame.delta_time_largest_observed.ToMicroseconds()
<< " missing_packets: [ ";
- for (SequenceNumberSet::const_iterator it =
- received_info.missing_packets.begin();
- it != received_info.missing_packets.end(); ++it) {
+ for (SequenceNumberSet::const_iterator it = ack_frame.missing_packets.begin();
+ it != ack_frame.missing_packets.end(); ++it) {
os << *it << " ";
}
os << " ] revived_packets: [ ";
- for (SequenceNumberSet::const_iterator it =
- received_info.revived_packets.begin();
- it != received_info.revived_packets.end(); ++it) {
+ for (SequenceNumberSet::const_iterator it = ack_frame.revived_packets.begin();
+ it != ack_frame.revived_packets.end(); ++it) {
os << *it << " ";
}
os << " ]";
os << "type { STOP_WAITING_FRAME } " << *(frame.stop_waiting_frame);
break;
}
+ case PING_FRAME: {
+ os << "type { PING_FRAME } ";
+ break;
+ }
default: {
LOG(ERROR) << "Unknown frame type: " << frame.type;
break;
return os;
}
-ostream& operator<<(ostream& os, const QuicAckFrame& ack_frame) {
- os << "sent info { " << ack_frame.sent_info << " } "
- << "received info { " << ack_frame.received_info << " }\n";
- return os;
-}
-
ostream& operator<<(ostream& os,
const QuicCongestionFeedbackFrame& congestion_frame) {
os << "type: " << congestion_frame.type;
switch (congestion_frame.type) {
- case kInterArrival: {
- const CongestionFeedbackMessageInterArrival& inter_arrival =
- congestion_frame.inter_arrival;
+ case kTimestamp: {
+ const CongestionFeedbackMessageTimestamp& timestamp =
+ congestion_frame.timestamp;
os << " received packets: [ ";
- for (TimeMap::const_iterator it =
- inter_arrival.received_packet_times.begin();
- it != inter_arrival.received_packet_times.end(); ++it) {
+ for (TimeMap::const_iterator it = timestamp.received_packet_times.begin();
+ it != timestamp.received_packet_times.end(); ++it) {
os << it->first << "@" << it->second.ToDebuggingValue() << " ";
}
os << "]";
break;
}
- case kFixRate: {
- os << " bitrate_in_bytes_per_second: "
- << congestion_frame.fix_rate.bitrate.ToBytesPerSecond();
- break;
- }
case kTCP: {
const CongestionFeedbackMessageTCP& tcp = congestion_frame.tcp;
os << " receive_window: " << tcp.receive_window;
break;
}
- case kTCPBBR: {
- LOG(DFATAL) << "TCPBBR is not yet supported.";
- break;
- }
}
return os;
}
-CongestionFeedbackMessageFixRate::CongestionFeedbackMessageFixRate()
- : bitrate(QuicBandwidth::Zero()) {
-}
-
QuicGoAwayFrame::QuicGoAwayFrame()
: error_code(QUIC_NO_ERROR),
last_good_stream_id(0) {