net/quic/test_tools/quic_sent_packet_manager_peer.cc

   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
  13 namespace net {
  14 namespace test {
  15
  16 // static
  17 size_t QuicSentPacketManagerPeer::GetMaxTailLossProbes(
  18     QuicSentPacketManager* sent_packet_manager) {
  19   return sent_packet_manager->max_tail_loss_probes_;
  20 }
  21
  22 // static
  23 void QuicSentPacketManagerPeer::SetMaxTailLossProbes(
  24     QuicSentPacketManager* sent_packet_manager, size_t max_tail_loss_probes) {
  25   sent_packet_manager->max_tail_loss_probes_ = max_tail_loss_probes;
  26 }
  27
  28 // static
  29 QuicByteCount QuicSentPacketManagerPeer::GetReceiveWindow(
  30     QuicSentPacketManager* sent_packet_manager) {
  31   return sent_packet_manager->receive_buffer_bytes_;
  32 }
  33
  34 // static
  35 void QuicSentPacketManagerPeer::SetIsServer(
  36     QuicSentPacketManager* sent_packet_manager,
  37     bool is_server) {
  38   sent_packet_manager->is_server_ = is_server;
  39 }
  40
  41 // static
  42 const SendAlgorithmInterface*
  43     QuicSentPacketManagerPeer::GetSendAlgorithm(
  44     const QuicSentPacketManager& sent_packet_manager) {
  45   return sent_packet_manager.send_algorithm_.get();
  46 }
  47
  48 // static
  49 void QuicSentPacketManagerPeer::SetSendAlgorithm(
  50     QuicSentPacketManager* sent_packet_manager,
  51     SendAlgorithmInterface* send_algorithm) {
  52   sent_packet_manager->send_algorithm_.reset(send_algorithm);
  53 }
  54
  55 // static
  56 const LossDetectionInterface* QuicSentPacketManagerPeer::GetLossAlgorithm(
  57     QuicSentPacketManager* sent_packet_manager) {
  58   return sent_packet_manager->loss_algorithm_.get();
  59 }
  60
  61 // static
  62 void QuicSentPacketManagerPeer::SetLossAlgorithm(
  63     QuicSentPacketManager* sent_packet_manager,
  64     LossDetectionInterface* loss_detector) {
  65   sent_packet_manager->loss_algorithm_.reset(loss_detector);
  66 }
  67
  68 // static
  69 RttStats* QuicSentPacketManagerPeer::GetRttStats(
  70     QuicSentPacketManager* sent_packet_manager) {
  71   return &sent_packet_manager->rtt_stats_;
  72 }
  73
  74 // static
  75 QuicPacketCount QuicSentPacketManagerPeer::GetNackCount(
  76     const QuicSentPacketManager* sent_packet_manager,
  77     QuicPacketSequenceNumber sequence_number) {
  78   return sent_packet_manager->unacked_packets_.
  79       GetTransmissionInfo(sequence_number).nack_count;
  80 }
  81
  82 // static
  83 size_t QuicSentPacketManagerPeer::GetPendingRetransmissionCount(
  84     const QuicSentPacketManager* sent_packet_manager) {
  85   return sent_packet_manager->pending_retransmissions_.size();
  86 }
  87
  88 // static
  89 bool QuicSentPacketManagerPeer::HasPendingPackets(
  90     const QuicSentPacketManager* sent_packet_manager) {
  91   return sent_packet_manager->unacked_packets_.HasInFlightPackets();
  92 }
  93
  94 // static
  95 QuicTime QuicSentPacketManagerPeer::GetSentTime(
  96     const QuicSentPacketManager* sent_packet_manager,
  97     QuicPacketSequenceNumber sequence_number) {
  98   DCHECK(sent_packet_manager->unacked_packets_.IsUnacked(sequence_number));
  99
 100   return sent_packet_manager->unacked_packets_.GetTransmissionInfo(
 101       sequence_number).sent_time;
 102 }
 103
 104 // static
 105 bool QuicSentPacketManagerPeer::IsRetransmission(
 106     QuicSentPacketManager* sent_packet_manager,
 107     QuicPacketSequenceNumber sequence_number) {
 108   DCHECK(sent_packet_manager->HasRetransmittableFrames(sequence_number));
 109   return sent_packet_manager->HasRetransmittableFrames(sequence_number) &&
 110       sent_packet_manager->unacked_packets_.GetTransmissionInfo(
 111           sequence_number).all_transmissions != nullptr;
 112 }
 113
 114 // static
 115 void QuicSentPacketManagerPeer::MarkForRetransmission(
 116     QuicSentPacketManager* sent_packet_manager,
 117     QuicPacketSequenceNumber sequence_number,
 118     TransmissionType transmission_type) {
 119   sent_packet_manager->MarkForRetransmission(sequence_number,
 120                                              transmission_type);
 121 }
 122
 123 // static
 124 QuicTime::Delta QuicSentPacketManagerPeer::GetRetransmissionDelay(
 125     const QuicSentPacketManager* sent_packet_manager) {
 126   return sent_packet_manager->GetRetransmissionDelay();
 127 }
 128
 129 // static
 130 bool QuicSentPacketManagerPeer::HasUnackedCryptoPackets(
 131     const QuicSentPacketManager* sent_packet_manager) {
 132   return sent_packet_manager->unacked_packets_.HasPendingCryptoPackets();
 133 }
 134
 135 // static
 136 size_t QuicSentPacketManagerPeer::GetNumRetransmittablePackets(
 137     const QuicSentPacketManager* sent_packet_manager) {
 138   size_t num_unacked_packets = 0;
 139   for (QuicUnackedPacketMap::const_iterator it =
 140            sent_packet_manager->unacked_packets_.begin();
 141        it != sent_packet_manager->unacked_packets_.end(); ++it) {
 142     if (it->retransmittable_frames != nullptr) {
 143       ++num_unacked_packets;
 144     }
 145   }
 146   return num_unacked_packets;
 147 }
 148
 149 // static
 150 QuicByteCount QuicSentPacketManagerPeer::GetBytesInFlight(
 151     const QuicSentPacketManager* sent_packet_manager) {
 152   return sent_packet_manager->unacked_packets_.bytes_in_flight();
 153 }
 154
 155 // static
 156 QuicSentPacketManager::NetworkChangeVisitor*
 157     QuicSentPacketManagerPeer::GetNetworkChangeVisitor(
 158         const QuicSentPacketManager* sent_packet_manager) {
 159   return sent_packet_manager->network_change_visitor_;
 160 }
 161
 162 // static
 163 QuicSustainedBandwidthRecorder& QuicSentPacketManagerPeer::GetBandwidthRecorder(
 164     QuicSentPacketManager* sent_packet_manager) {
 165   return sent_packet_manager->sustained_bandwidth_recorder_;
 166 }
 167
 168 }  // namespace test
 169 }  // namespace net