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 "quiche/quic/test_tools/quic_sent_packet_manager_peer.h"
6
7 #include "quiche/quic/core/congestion_control/loss_detection_interface.h"
8 #include "quiche/quic/core/congestion_control/send_algorithm_interface.h"
9 #include "quiche/quic/core/quic_packets.h"
10 #include "quiche/quic/core/quic_sent_packet_manager.h"
11 #include "quiche/quic/test_tools/quic_unacked_packet_map_peer.h"
12
13 namespace quic {
14 namespace test {
15
16
17 // static
SetPerspective(QuicSentPacketManager * sent_packet_manager,Perspective perspective)18 void QuicSentPacketManagerPeer::SetPerspective(
19 QuicSentPacketManager* sent_packet_manager, Perspective perspective) {
20 QuicUnackedPacketMapPeer::SetPerspective(
21 &sent_packet_manager->unacked_packets_, perspective);
22 }
23
24 // static
GetSendAlgorithm(const QuicSentPacketManager & sent_packet_manager)25 SendAlgorithmInterface* QuicSentPacketManagerPeer::GetSendAlgorithm(
26 const QuicSentPacketManager& sent_packet_manager) {
27 return sent_packet_manager.send_algorithm_.get();
28 }
29
30 // static
SetSendAlgorithm(QuicSentPacketManager * sent_packet_manager,SendAlgorithmInterface * send_algorithm)31 void QuicSentPacketManagerPeer::SetSendAlgorithm(
32 QuicSentPacketManager* sent_packet_manager,
33 SendAlgorithmInterface* send_algorithm) {
34 sent_packet_manager->SetSendAlgorithm(send_algorithm);
35 }
36
37 // static
GetLossAlgorithm(QuicSentPacketManager * sent_packet_manager)38 const LossDetectionInterface* QuicSentPacketManagerPeer::GetLossAlgorithm(
39 QuicSentPacketManager* sent_packet_manager) {
40 return sent_packet_manager->loss_algorithm_;
41 }
42
43 // static
SetLossAlgorithm(QuicSentPacketManager * sent_packet_manager,LossDetectionInterface * loss_detector)44 void QuicSentPacketManagerPeer::SetLossAlgorithm(
45 QuicSentPacketManager* sent_packet_manager,
46 LossDetectionInterface* loss_detector) {
47 sent_packet_manager->loss_algorithm_ = loss_detector;
48 }
49
50 // static
GetRttStats(QuicSentPacketManager * sent_packet_manager)51 RttStats* QuicSentPacketManagerPeer::GetRttStats(
52 QuicSentPacketManager* sent_packet_manager) {
53 return &sent_packet_manager->rtt_stats_;
54 }
55
56 // static
IsRetransmission(QuicSentPacketManager * sent_packet_manager,uint64_t packet_number)57 bool QuicSentPacketManagerPeer::IsRetransmission(
58 QuicSentPacketManager* sent_packet_manager, uint64_t packet_number) {
59 QUICHE_DCHECK(HasRetransmittableFrames(sent_packet_manager, packet_number));
60 if (!HasRetransmittableFrames(sent_packet_manager, packet_number)) {
61 return false;
62 }
63 return sent_packet_manager->unacked_packets_
64 .GetTransmissionInfo(QuicPacketNumber(packet_number))
65 .transmission_type != NOT_RETRANSMISSION;
66 }
67
68 // static
MarkForRetransmission(QuicSentPacketManager * sent_packet_manager,uint64_t packet_number,TransmissionType transmission_type)69 void QuicSentPacketManagerPeer::MarkForRetransmission(
70 QuicSentPacketManager* sent_packet_manager, uint64_t packet_number,
71 TransmissionType transmission_type) {
72 sent_packet_manager->MarkForRetransmission(QuicPacketNumber(packet_number),
73 transmission_type);
74 }
75
76 // static
GetNumRetransmittablePackets(const QuicSentPacketManager * sent_packet_manager)77 size_t QuicSentPacketManagerPeer::GetNumRetransmittablePackets(
78 const QuicSentPacketManager* sent_packet_manager) {
79 size_t num_unacked_packets = 0;
80 for (auto it = sent_packet_manager->unacked_packets_.begin();
81 it != sent_packet_manager->unacked_packets_.end(); ++it) {
82 if (sent_packet_manager->unacked_packets_.HasRetransmittableFrames(*it)) {
83 ++num_unacked_packets;
84 }
85 }
86 return num_unacked_packets;
87 }
88
89 // static
SetConsecutivePtoCount(QuicSentPacketManager * sent_packet_manager,size_t count)90 void QuicSentPacketManagerPeer::SetConsecutivePtoCount(
91 QuicSentPacketManager* sent_packet_manager, size_t count) {
92 sent_packet_manager->consecutive_pto_count_ = count;
93 }
94
95 // static
GetBandwidthRecorder(QuicSentPacketManager * sent_packet_manager)96 QuicSustainedBandwidthRecorder& QuicSentPacketManagerPeer::GetBandwidthRecorder(
97 QuicSentPacketManager* sent_packet_manager) {
98 return sent_packet_manager->sustained_bandwidth_recorder_;
99 }
100
101 // static
UsingPacing(const QuicSentPacketManager * sent_packet_manager)102 bool QuicSentPacketManagerPeer::UsingPacing(
103 const QuicSentPacketManager* sent_packet_manager) {
104 return sent_packet_manager->using_pacing_;
105 }
106
107 // static
SetUsingPacing(QuicSentPacketManager * sent_packet_manager,bool using_pacing)108 void QuicSentPacketManagerPeer::SetUsingPacing(
109 QuicSentPacketManager* sent_packet_manager, bool using_pacing) {
110 sent_packet_manager->using_pacing_ = using_pacing;
111 }
112
113 // static
HasRetransmittableFrames(QuicSentPacketManager * sent_packet_manager,uint64_t packet_number)114 bool QuicSentPacketManagerPeer::HasRetransmittableFrames(
115 QuicSentPacketManager* sent_packet_manager, uint64_t packet_number) {
116 return sent_packet_manager->unacked_packets_.HasRetransmittableFrames(
117 QuicPacketNumber(packet_number));
118 }
119
120 // static
GetUnackedPacketMap(QuicSentPacketManager * sent_packet_manager)121 QuicUnackedPacketMap* QuicSentPacketManagerPeer::GetUnackedPacketMap(
122 QuicSentPacketManager* sent_packet_manager) {
123 return &sent_packet_manager->unacked_packets_;
124 }
125
126 // static
DisablePacerBursts(QuicSentPacketManager * sent_packet_manager)127 void QuicSentPacketManagerPeer::DisablePacerBursts(
128 QuicSentPacketManager* sent_packet_manager) {
129 sent_packet_manager->pacing_sender_.burst_tokens_ = 0;
130 sent_packet_manager->pacing_sender_.initial_burst_size_ = 0;
131 }
132
133 // static
GetPacerInitialBurstSize(QuicSentPacketManager * sent_packet_manager)134 int QuicSentPacketManagerPeer::GetPacerInitialBurstSize(
135 QuicSentPacketManager* sent_packet_manager) {
136 return sent_packet_manager->pacing_sender_.initial_burst_size_;
137 }
138
139 // static
SetNextPacedPacketTime(QuicSentPacketManager * sent_packet_manager,QuicTime time)140 void QuicSentPacketManagerPeer::SetNextPacedPacketTime(
141 QuicSentPacketManager* sent_packet_manager, QuicTime time) {
142 sent_packet_manager->pacing_sender_.ideal_next_packet_send_time_ = time;
143 }
144
145 // static
GetReorderingShift(QuicSentPacketManager * sent_packet_manager)146 int QuicSentPacketManagerPeer::GetReorderingShift(
147 QuicSentPacketManager* sent_packet_manager) {
148 return sent_packet_manager->uber_loss_algorithm_.general_loss_algorithms_[0]
149 .reordering_shift();
150 }
151
152 // static
AdaptiveReorderingThresholdEnabled(QuicSentPacketManager * sent_packet_manager)153 bool QuicSentPacketManagerPeer::AdaptiveReorderingThresholdEnabled(
154 QuicSentPacketManager* sent_packet_manager) {
155 return sent_packet_manager->uber_loss_algorithm_.general_loss_algorithms_[0]
156 .use_adaptive_reordering_threshold();
157 }
158
159 // static
AdaptiveTimeThresholdEnabled(QuicSentPacketManager * sent_packet_manager)160 bool QuicSentPacketManagerPeer::AdaptiveTimeThresholdEnabled(
161 QuicSentPacketManager* sent_packet_manager) {
162 return sent_packet_manager->uber_loss_algorithm_.general_loss_algorithms_[0]
163 .use_adaptive_time_threshold();
164 }
165
166 // static
UsePacketThresholdForRuntPackets(QuicSentPacketManager * sent_packet_manager)167 bool QuicSentPacketManagerPeer::UsePacketThresholdForRuntPackets(
168 QuicSentPacketManager* sent_packet_manager) {
169 return sent_packet_manager->uber_loss_algorithm_.general_loss_algorithms_[0]
170 .use_packet_threshold_for_runt_packets();
171 }
172
173 // static
GetNumPtosForPathDegrading(QuicSentPacketManager * sent_packet_manager)174 int QuicSentPacketManagerPeer::GetNumPtosForPathDegrading(
175 QuicSentPacketManager* sent_packet_manager) {
176 return sent_packet_manager->num_ptos_for_path_degrading_;
177 }
178
179 // static
GetPeerEcnCounts(QuicSentPacketManager * sent_packet_manager,PacketNumberSpace space)180 QuicEcnCounts* QuicSentPacketManagerPeer::GetPeerEcnCounts(
181 QuicSentPacketManager* sent_packet_manager, PacketNumberSpace space) {
182 return &(sent_packet_manager->peer_ack_ecn_counts_[space]);
183 }
184
185 } // namespace test
186 } // namespace quic
187