src/net/quic/test_tools/quic_connection_peer.cc

   1 // Copyright (c) 2012 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_connection_peer.h"
   6
   7 #include "base/stl_util.h"
   8 #include "net/quic/congestion_control/quic_congestion_manager.h"
   9 #include "net/quic/congestion_control/receive_algorithm_interface.h"
  10 #include "net/quic/congestion_control/send_algorithm_interface.h"
  11 #include "net/quic/quic_connection.h"
  12 #include "net/quic/quic_packet_writer.h"
  13 #include "net/quic/test_tools/quic_framer_peer.h"
  14 #include "net/quic/test_tools/quic_test_writer.h"
  15
  16 namespace net {
  17 namespace test {
  18
  19 // static
  20 void QuicConnectionPeer::SendAck(QuicConnection* connection) {
  21   connection->SendAck();
  22 }
  23
  24 // static
  25 void QuicConnectionPeer::SetReceiveAlgorithm(
  26     QuicConnection* connection,
  27     ReceiveAlgorithmInterface* receive_algorithm) {
  28   connection->congestion_manager_.receive_algorithm_.reset(receive_algorithm);
  29 }
  30
  31 // static
  32 void QuicConnectionPeer::SetSendAlgorithm(
  33     QuicConnection* connection,
  34     SendAlgorithmInterface* send_algorithm) {
  35   connection->congestion_manager_.send_algorithm_.reset(send_algorithm);
  36 }
  37
  38 // static
  39 QuicAckFrame* QuicConnectionPeer::CreateAckFrame(QuicConnection* connection) {
  40   return connection->CreateAckFrame();
  41 }
  42
  43 // static
  44 QuicConnectionVisitorInterface* QuicConnectionPeer::GetVisitor(
  45     QuicConnection* connection) {
  46   return connection->visitor_;
  47 }
  48
  49 // static
  50 QuicPacketCreator* QuicConnectionPeer::GetPacketCreator(
  51     QuicConnection* connection) {
  52   return &connection->packet_creator_;
  53 }
  54
  55 // static
  56 QuicCongestionManager* QuicConnectionPeer::GetCongestionManager(
  57     QuicConnection* connection) {
  58   return &connection->congestion_manager_;
  59 }
  60
  61 bool QuicConnectionPeer::GetReceivedTruncatedAck(QuicConnection* connection) {
  62     return connection->received_truncated_ack_;
  63 }
  64
  65 // static
  66 QuicTime::Delta QuicConnectionPeer::GetNetworkTimeout(
  67     QuicConnection* connection) {
  68   return connection->idle_network_timeout_;
  69 }
  70
  71 // static
  72 bool QuicConnectionPeer::IsSavedForRetransmission(
  73     QuicConnection* connection,
  74     QuicPacketSequenceNumber sequence_number) {
  75   return connection->sent_packet_manager_.IsUnacked(sequence_number) &&
  76       connection->sent_packet_manager_.HasRetransmittableFrames(
  77           sequence_number);
  78 }
  79
  80 // static
  81 size_t QuicConnectionPeer::GetRetransmissionCount(
  82     QuicConnection* connection,
  83     QuicPacketSequenceNumber sequence_number) {
  84   return connection->sent_packet_manager_.GetRetransmissionCount(
  85       sequence_number);
  86 }
  87
  88 // static
  89 QuicPacketEntropyHash QuicConnectionPeer::GetSentEntropyHash(
  90     QuicConnection* connection,
  91     QuicPacketSequenceNumber sequence_number) {
  92   return connection->sent_entropy_manager_.EntropyHash(sequence_number);
  93 }
  94
  95 // static
  96 bool QuicConnectionPeer::IsValidEntropy(
  97     QuicConnection* connection,
  98     QuicPacketSequenceNumber largest_observed,
  99     const SequenceNumberSet& missing_packets,
 100     QuicPacketEntropyHash entropy_hash) {
 101   return connection->sent_entropy_manager_.IsValidEntropy(
 102       largest_observed, missing_packets, entropy_hash);
 103 }
 104
 105 // static
 106 QuicPacketEntropyHash QuicConnectionPeer::ReceivedEntropyHash(
 107     QuicConnection* connection,
 108     QuicPacketSequenceNumber sequence_number) {
 109   return connection->received_packet_manager_.EntropyHash(
 110       sequence_number);
 111 }
 112
 113 // static
 114 bool QuicConnectionPeer::IsWriteBlocked(QuicConnection* connection) {
 115   return connection->write_blocked_;
 116 }
 117
 118 // static
 119 void QuicConnectionPeer::SetIsWriteBlocked(QuicConnection* connection,
 120                                            bool write_blocked) {
 121   connection->write_blocked_ = write_blocked;
 122 }
 123
 124 // static
 125 bool QuicConnectionPeer::IsServer(QuicConnection* connection) {
 126   return connection->is_server_;
 127 }
 128
 129 // static
 130 void QuicConnectionPeer::SetIsServer(QuicConnection* connection,
 131                                      bool is_server) {
 132   connection->is_server_ = is_server;
 133   QuicFramerPeer::SetIsServer(&connection->framer_, is_server);
 134 }
 135
 136 // static
 137 void QuicConnectionPeer::SetSelfAddress(QuicConnection* connection,
 138                                         const IPEndPoint& self_address) {
 139   connection->self_address_ = self_address;
 140 }
 141
 142 // static
 143 void QuicConnectionPeer::SetPeerAddress(QuicConnection* connection,
 144                                         const IPEndPoint& peer_address) {
 145   connection->peer_address_ = peer_address;
 146 }
 147
 148 // static
 149 void QuicConnectionPeer::SwapCrypters(QuicConnection* connection,
 150                                       QuicFramer* framer) {
 151   framer->SwapCryptersForTest(&connection->framer_);
 152 }
 153
 154 // static
 155 QuicConnectionHelperInterface* QuicConnectionPeer::GetHelper(
 156     QuicConnection* connection) {
 157   return connection->helper_;
 158 }
 159
 160 // static
 161 QuicFramer* QuicConnectionPeer::GetFramer(QuicConnection* connection) {
 162   return &connection->framer_;
 163 }
 164
 165 QuicFecGroup* QuicConnectionPeer::GetFecGroup(QuicConnection* connection,
 166                                               int fec_group) {
 167   connection->last_header_.fec_group = fec_group;
 168   return connection->GetFecGroup();
 169 }
 170
 171 // static
 172 QuicAlarm* QuicConnectionPeer::GetAckAlarm(QuicConnection* connection) {
 173   return connection->ack_alarm_.get();
 174 }
 175
 176 // static
 177 QuicAlarm* QuicConnectionPeer::GetRetransmissionAlarm(
 178     QuicConnection* connection) {
 179   return connection->retransmission_alarm_.get();
 180 }
 181
 182 // static
 183 QuicAlarm* QuicConnectionPeer::GetSendAlarm(QuicConnection* connection) {
 184   return connection->send_alarm_.get();
 185 }
 186
 187 // static
 188 QuicAlarm* QuicConnectionPeer::GetResumeWritesAlarm(
 189     QuicConnection* connection) {
 190   return connection->resume_writes_alarm_.get();
 191 }
 192
 193 // static
 194 QuicAlarm* QuicConnectionPeer::GetTimeoutAlarm(QuicConnection* connection) {
 195   return connection->timeout_alarm_.get();
 196 }
 197
 198 // static
 199 QuicPacketWriter* QuicConnectionPeer::GetWriter(QuicConnection* connection) {
 200   return connection->writer_;
 201 }
 202
 203 // static
 204 void QuicConnectionPeer::SetWriter(QuicConnection* connection,
 205                                    QuicTestWriter* writer) {
 206   connection->writer_ = writer;
 207 }
 208
 209 }  // namespace test
 210 }  // namespace net