1// Copyright 2013 The Chromium Authors. All rights reserved.
2// Use of this source code is governed by a BSD-style license that can be
3// found in the LICENSE file.
4
5#include "net/quic/test_tools/quic_sent_packet_manager_peer.h"
6
7#include "base/stl_util.h"
8#include "net/quic/congestion_control/loss_detection_interface.h"
9#include "net/quic/congestion_control/send_algorithm_interface.h"
10#include "net/quic/quic_protocol.h"
11#include "net/quic/quic_sent_packet_manager.h"
12
13namespace net {
14namespace test {
15
16// static
17void QuicSentPacketManagerPeer::SetMaxTailLossProbes(
18    QuicSentPacketManager* sent_packet_manager, size_t max_tail_loss_probes) {
19  sent_packet_manager->max_tail_loss_probes_ = max_tail_loss_probes;
20}
21
22// static
23void QuicSentPacketManagerPeer::SetSendAlgorithm(
24    QuicSentPacketManager* sent_packet_manager,
25    SendAlgorithmInterface* send_algorithm) {
26  sent_packet_manager->send_algorithm_.reset(send_algorithm);
27}
28
29// static
30const LossDetectionInterface* QuicSentPacketManagerPeer::GetLossAlgorithm(
31    QuicSentPacketManager* sent_packet_manager) {
32  return sent_packet_manager->loss_algorithm_.get();
33}
34
35// static
36void QuicSentPacketManagerPeer::SetLossAlgorithm(
37    QuicSentPacketManager* sent_packet_manager,
38    LossDetectionInterface* loss_detector) {
39  sent_packet_manager->loss_algorithm_.reset(loss_detector);
40}
41
42// static
43RttStats* QuicSentPacketManagerPeer::GetRttStats(
44    QuicSentPacketManager* sent_packet_manager) {
45  return &sent_packet_manager->rtt_stats_;
46}
47
48// static
49size_t QuicSentPacketManagerPeer::GetNackCount(
50    const QuicSentPacketManager* sent_packet_manager,
51    QuicPacketSequenceNumber sequence_number) {
52  return sent_packet_manager->unacked_packets_.
53      GetTransmissionInfo(sequence_number).nack_count;
54}
55
56// static
57size_t QuicSentPacketManagerPeer::GetPendingRetransmissionCount(
58    const QuicSentPacketManager* sent_packet_manager) {
59  return sent_packet_manager->pending_retransmissions_.size();
60}
61
62// static
63bool QuicSentPacketManagerPeer::HasPendingPackets(
64    const QuicSentPacketManager* sent_packet_manager) {
65  return sent_packet_manager->unacked_packets_.HasInFlightPackets();
66}
67
68// static
69QuicTime QuicSentPacketManagerPeer::GetSentTime(
70    const QuicSentPacketManager* sent_packet_manager,
71    QuicPacketSequenceNumber sequence_number) {
72  DCHECK(sent_packet_manager->unacked_packets_.IsUnacked(sequence_number));
73
74  return sent_packet_manager->unacked_packets_.GetTransmissionInfo(
75      sequence_number).sent_time;
76}
77
78// static
79bool QuicSentPacketManagerPeer::IsRetransmission(
80    QuicSentPacketManager* sent_packet_manager,
81    QuicPacketSequenceNumber sequence_number) {
82  DCHECK(sent_packet_manager->HasRetransmittableFrames(sequence_number));
83  return sent_packet_manager->HasRetransmittableFrames(sequence_number) &&
84      sent_packet_manager->unacked_packets_.GetTransmissionInfo(
85          sequence_number).all_transmissions->size() > 1;
86}
87
88// static
89void QuicSentPacketManagerPeer::MarkForRetransmission(
90    QuicSentPacketManager* sent_packet_manager,
91    QuicPacketSequenceNumber sequence_number,
92    TransmissionType transmission_type) {
93  sent_packet_manager->MarkForRetransmission(sequence_number,
94                                             transmission_type);
95}
96
97// static
98QuicTime::Delta QuicSentPacketManagerPeer::GetRetransmissionDelay(
99    const QuicSentPacketManager* sent_packet_manager) {
100  return sent_packet_manager->GetRetransmissionDelay();
101}
102
103// static
104bool QuicSentPacketManagerPeer::HasUnackedCryptoPackets(
105    const QuicSentPacketManager* sent_packet_manager) {
106  return sent_packet_manager->unacked_packets_.HasPendingCryptoPackets();
107}
108
109// static
110size_t QuicSentPacketManagerPeer::GetNumRetransmittablePackets(
111    const QuicSentPacketManager* sent_packet_manager) {
112  size_t num_unacked_packets = 0;
113  for (QuicUnackedPacketMap::const_iterator it =
114           sent_packet_manager->unacked_packets_.begin();
115       it != sent_packet_manager->unacked_packets_.end(); ++it) {
116    if (it->second.retransmittable_frames != NULL) {
117      ++num_unacked_packets;
118    }
119  }
120  return num_unacked_packets;
121}
122
123// static
124QuicByteCount QuicSentPacketManagerPeer::GetBytesInFlight(
125    const QuicSentPacketManager* sent_packet_manager) {
126  return sent_packet_manager->unacked_packets_.bytes_in_flight();
127}
128
129}  // namespace test
130}  // namespace net
131