quiche/quic/test_tools/quic_sent_packet_manager_peer.cc

// Copyright 2013 The Chromium Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.

#include "quiche/quic/test_tools/quic_sent_packet_manager_peer.h"

#include "quiche/quic/core/congestion_control/loss_detection_interface.h"
#include "quiche/quic/core/congestion_control/send_algorithm_interface.h"
#include "quiche/quic/core/quic_packets.h"
#include "quiche/quic/core/quic_sent_packet_manager.h"
#include "quiche/quic/test_tools/quic_unacked_packet_map_peer.h"

namespace quic {
namespace test {


// static
void QuicSentPacketManagerPeer::SetPerspective(
    QuicSentPacketManager* sent_packet_manager, Perspective perspective) {
  QuicUnackedPacketMapPeer::SetPerspective(
      &sent_packet_manager->unacked_packets_, perspective);
}

// static
SendAlgorithmInterface* QuicSentPacketManagerPeer::GetSendAlgorithm(
    const QuicSentPacketManager& sent_packet_manager) {
  return sent_packet_manager.send_algorithm_.get();
}

// static
void QuicSentPacketManagerPeer::SetSendAlgorithm(
    QuicSentPacketManager* sent_packet_manager,
    SendAlgorithmInterface* send_algorithm) {
  sent_packet_manager->SetSendAlgorithm(send_algorithm);
}

// static
const LossDetectionInterface* QuicSentPacketManagerPeer::GetLossAlgorithm(
    QuicSentPacketManager* sent_packet_manager) {
  return sent_packet_manager->loss_algorithm_;
}

// static
void QuicSentPacketManagerPeer::SetLossAlgorithm(
    QuicSentPacketManager* sent_packet_manager,
    LossDetectionInterface* loss_detector) {
  sent_packet_manager->loss_algorithm_ = loss_detector;
}

// static
RttStats* QuicSentPacketManagerPeer::GetRttStats(
    QuicSentPacketManager* sent_packet_manager) {
  return &sent_packet_manager->rtt_stats_;
}

// static
bool QuicSentPacketManagerPeer::IsRetransmission(
    QuicSentPacketManager* sent_packet_manager, uint64_t packet_number) {
  QUICHE_DCHECK(HasRetransmittableFrames(sent_packet_manager, packet_number));
  if (!HasRetransmittableFrames(sent_packet_manager, packet_number)) {
    return false;
  }
  return sent_packet_manager->unacked_packets_
             .GetTransmissionInfo(QuicPacketNumber(packet_number))
             .transmission_type != NOT_RETRANSMISSION;
}

// static
void QuicSentPacketManagerPeer::MarkForRetransmission(
    QuicSentPacketManager* sent_packet_manager, uint64_t packet_number,
    TransmissionType transmission_type) {
  sent_packet_manager->MarkForRetransmission(QuicPacketNumber(packet_number),
                                             transmission_type);
}

// static
size_t QuicSentPacketManagerPeer::GetNumRetransmittablePackets(
    const QuicSentPacketManager* sent_packet_manager) {
  size_t num_unacked_packets = 0;
  for (auto it = sent_packet_manager->unacked_packets_.begin();
       it != sent_packet_manager->unacked_packets_.end(); ++it) {
    if (sent_packet_manager->unacked_packets_.HasRetransmittableFrames(*it)) {
      ++num_unacked_packets;
    }
  }
  return num_unacked_packets;
}

// static
void QuicSentPacketManagerPeer::SetConsecutivePtoCount(
    QuicSentPacketManager* sent_packet_manager, size_t count) {
  sent_packet_manager->consecutive_pto_count_ = count;
}

// static
QuicSustainedBandwidthRecorder& QuicSentPacketManagerPeer::GetBandwidthRecorder(
    QuicSentPacketManager* sent_packet_manager) {
  return sent_packet_manager->sustained_bandwidth_recorder_;
}

// static
bool QuicSentPacketManagerPeer::UsingPacing(
    const QuicSentPacketManager* sent_packet_manager) {
  return sent_packet_manager->using_pacing_;
}

// static
void QuicSentPacketManagerPeer::SetUsingPacing(
    QuicSentPacketManager* sent_packet_manager, bool using_pacing) {
  sent_packet_manager->using_pacing_ = using_pacing;
}

// static
bool QuicSentPacketManagerPeer::HasRetransmittableFrames(
    QuicSentPacketManager* sent_packet_manager, uint64_t packet_number) {
  return sent_packet_manager->unacked_packets_.HasRetransmittableFrames(
      QuicPacketNumber(packet_number));
}

// static
QuicUnackedPacketMap* QuicSentPacketManagerPeer::GetUnackedPacketMap(
    QuicSentPacketManager* sent_packet_manager) {
  return &sent_packet_manager->unacked_packets_;
}

// static
void QuicSentPacketManagerPeer::DisablePacerBursts(
    QuicSentPacketManager* sent_packet_manager) {
  sent_packet_manager->pacing_sender_.burst_tokens_ = 0;
  sent_packet_manager->pacing_sender_.initial_burst_size_ = 0;
}

// static
int QuicSentPacketManagerPeer::GetPacerInitialBurstSize(
    QuicSentPacketManager* sent_packet_manager) {
  return sent_packet_manager->pacing_sender_.initial_burst_size_;
}

// static
void QuicSentPacketManagerPeer::SetNextPacedPacketTime(
    QuicSentPacketManager* sent_packet_manager, QuicTime time) {
  sent_packet_manager->pacing_sender_.ideal_next_packet_send_time_ = time;
}

// static
int QuicSentPacketManagerPeer::GetReorderingShift(
    QuicSentPacketManager* sent_packet_manager) {
  return sent_packet_manager->uber_loss_algorithm_.general_loss_algorithms_[0]
      .reordering_shift();
}

// static
bool QuicSentPacketManagerPeer::AdaptiveReorderingThresholdEnabled(
    QuicSentPacketManager* sent_packet_manager) {
  return sent_packet_manager->uber_loss_algorithm_.general_loss_algorithms_[0]
      .use_adaptive_reordering_threshold();
}

// static
bool QuicSentPacketManagerPeer::AdaptiveTimeThresholdEnabled(
    QuicSentPacketManager* sent_packet_manager) {
  return sent_packet_manager->uber_loss_algorithm_.general_loss_algorithms_[0]
      .use_adaptive_time_threshold();
}

// static
bool QuicSentPacketManagerPeer::UsePacketThresholdForRuntPackets(
    QuicSentPacketManager* sent_packet_manager) {
  return sent_packet_manager->uber_loss_algorithm_.general_loss_algorithms_[0]
      .use_packet_threshold_for_runt_packets();
}

// static
int QuicSentPacketManagerPeer::GetNumPtosForPathDegrading(
    QuicSentPacketManager* sent_packet_manager) {
  return sent_packet_manager->num_ptos_for_path_degrading_;
}

}  // namespace test
}  // namespace quic