src/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 void 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
  23 void QuicSentPacketManagerPeer::SetSendAlgorithm(
  24     QuicSentPacketManager* sent_packet_manager,
  25     SendAlgorithmInterface* send_algorithm) {
  26   sent_packet_manager->send_algorithm_.reset(send_algorithm);
  27 }
  28
  29 // static
  30 const LossDetectionInterface* QuicSentPacketManagerPeer::GetLossAlgorithm(
  31     QuicSentPacketManager* sent_packet_manager) {
  32   return sent_packet_manager->loss_algorithm_.get();
  33 }
  34
  35 // static
  36 void QuicSentPacketManagerPeer::SetLossAlgorithm(
  37     QuicSentPacketManager* sent_packet_manager,
  38     LossDetectionInterface* loss_detector) {
  39   sent_packet_manager->loss_algorithm_.reset(loss_detector);
  40 }
  41
  42 // static
  43 RttStats* QuicSentPacketManagerPeer::GetRttStats(
  44     QuicSentPacketManager* sent_packet_manager) {
  45   return &sent_packet_manager->rtt_stats_;
  46 }
  47
  48 // static
  49 size_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
  57 size_t QuicSentPacketManagerPeer::GetPendingRetransmissionCount(
  58     const QuicSentPacketManager* sent_packet_manager) {
  59   return sent_packet_manager->pending_retransmissions_.size();
  60 }
  61
  62 // static
  63 bool QuicSentPacketManagerPeer::HasPendingPackets(
  64     const QuicSentPacketManager* sent_packet_manager) {
  65   return sent_packet_manager->unacked_packets_.HasPendingPackets();
  66 }
  67
  68 // static
  69 QuicTime 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
  79 bool 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
  89 void 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
  98 QuicTime::Delta QuicSentPacketManagerPeer::GetRetransmissionDelay(
  99     const QuicSentPacketManager* sent_packet_manager) {
 100   return sent_packet_manager->GetRetransmissionDelay();
 101 }
 102
 103 // static
 104 bool QuicSentPacketManagerPeer::HasUnackedCryptoPackets(
 105     const QuicSentPacketManager* sent_packet_manager) {
 106   return sent_packet_manager->unacked_packets_.HasPendingCryptoPackets();
 107 }
 108
 109 // static
 110 size_t QuicSentPacketManagerPeer::GetNumRetransmittablePackets(
 111     const QuicSentPacketManager* sent_packet_manager) {
 112   return sent_packet_manager->unacked_packets_.GetNumRetransmittablePackets();
 113 }
 114
 115 // static
 116 SequenceNumberSet QuicSentPacketManagerPeer::GetUnackedPackets(
 117     const QuicSentPacketManager* sent_packet_manager) {
 118   return sent_packet_manager->unacked_packets_.GetUnackedPackets();
 119 }
 120
 121 // static
 122 QuicByteCount QuicSentPacketManagerPeer::GetBytesInFlight(
 123     const QuicSentPacketManager* sent_packet_manager) {
 124   return sent_packet_manager->unacked_packets_.bytes_in_flight();
 125 }
 126
 127 }  // namespace test
 128 }  // namespace net