#include "base/logging.h"
#include "base/stl_util.h"
#include "net/base/linked_hash_map.h"
+#include "net/quic/quic_connection_stats.h"
using std::make_pair;
using std::max;
}
QuicReceivedPacketManager::QuicReceivedPacketManager(
- CongestionFeedbackType congestion_type)
+ CongestionFeedbackType congestion_type,
+ QuicConnectionStats* stats)
: packets_entropy_hash_(0),
largest_sequence_number_(0),
peer_largest_observed_packet_(0),
least_packet_awaited_by_peer_(1),
peer_least_packet_awaiting_ack_(0),
time_largest_observed_(QuicTime::Zero()),
- receive_algorithm_(ReceiveAlgorithmInterface::Create(congestion_type)) {
+ receive_algorithm_(ReceiveAlgorithmInterface::Create(congestion_type)),
+ stats_(stats) {
received_info_.largest_observed = 0;
received_info_.entropy_hash = 0;
}
// "missing packets" list.
DVLOG(1) << "Removing " << sequence_number << " from missing list";
received_info_.missing_packets.erase(sequence_number);
+
+ // Record how out of order stats.
+ ++stats_->packets_reordered;
+ uint32 sequence_gap = received_info_.largest_observed - sequence_number;
+ stats_->max_sequence_reordering =
+ max(stats_->max_sequence_reordering, sequence_gap);
+ uint32 reordering_time_us =
+ receipt_time.Subtract(time_largest_observed_).ToMicroseconds();
+ stats_->max_time_reordering_us = max(stats_->max_time_reordering_us,
+ reordering_time_us);
}
if (header.packet_sequence_number > received_info_.largest_observed) {
received_info_.largest_observed = header.packet_sequence_number;
QuicPacketEntropyHash entropy_hash) {
if (sequence_number < largest_sequence_number_) {
DVLOG(1) << "Ignoring received packet entropy for sequence_number:"
- << sequence_number << " less than largest_peer_sequence_number:"
- << largest_sequence_number_;
+ << sequence_number << " less than largest_peer_sequence_number:"
+ << largest_sequence_number_;
return;
}
packets_entropy_.insert(make_pair(sequence_number, entropy_hash));
DCHECK_LE(peer_least_unacked, received_info_.largest_observed);
if (peer_least_unacked < largest_sequence_number_) {
DVLOG(1) << "Ignoring received peer_least_unacked:" << peer_least_unacked
- << " less than largest_peer_sequence_number:"
- << largest_sequence_number_;
+ << " less than largest_peer_sequence_number:"
+ << largest_sequence_number_;
return;
}
largest_sequence_number_ = peer_least_unacked;
}
void QuicReceivedPacketManager::UpdatePacketInformationSentByPeer(
- const SentPacketInfo& sent_info) {
+ const QuicStopWaitingFrame& stop_waiting) {
// ValidateAck() should fail if peer_least_packet_awaiting_ack_ shrinks.
- DCHECK_LE(peer_least_packet_awaiting_ack_, sent_info.least_unacked);
- if (sent_info.least_unacked > peer_least_packet_awaiting_ack_) {
- bool missed_packets = DontWaitForPacketsBefore(sent_info.least_unacked);
- if (missed_packets || sent_info.least_unacked >
+ DCHECK_LE(peer_least_packet_awaiting_ack_, stop_waiting.least_unacked);
+ if (stop_waiting.least_unacked > peer_least_packet_awaiting_ack_) {
+ bool missed_packets = DontWaitForPacketsBefore(stop_waiting.least_unacked);
+ if (missed_packets || stop_waiting.least_unacked >
received_info_.largest_observed + 1) {
DVLOG(1) << "Updating entropy hashed since we missed packets";
// There were some missing packets that we won't ever get now. Recalculate
// the received entropy hash.
- RecalculateEntropyHash(sent_info.least_unacked, sent_info.entropy_hash);
+ RecalculateEntropyHash(stop_waiting.least_unacked,
+ stop_waiting.entropy_hash);
}
- peer_least_packet_awaiting_ack_ = sent_info.least_unacked;
+ peer_least_packet_awaiting_ack_ = stop_waiting.least_unacked;
}
DCHECK(received_info_.missing_packets.empty() ||
*received_info_.missing_packets.begin() >=