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/receive_algorithm_interface.h"
   9 #include "net/quic/congestion_control/send_algorithm_interface.h"
  10 #include "net/quic/quic_connection.h"
  11 #include "net/quic/quic_packet_writer.h"
  12 #include "net/quic/quic_received_packet_manager.h"
  13 #include "net/quic/test_tools/quic_framer_peer.h"
  14 #include "net/quic/test_tools/quic_packet_generator_peer.h"
  15 #include "net/quic/test_tools/quic_sent_packet_manager_peer.h"
  16
  17 namespace net {
  18 namespace test {
  19
  20 // static
  21 void QuicConnectionPeer::SendAck(QuicConnection* connection) {
  22   connection->SendAck();
  23 }
  24
  25 // static
  26 void QuicConnectionPeer::SetReceiveAlgorithm(
  27     QuicConnection* connection,
  28     ReceiveAlgorithmInterface* receive_algorithm) {
  29   connection->received_packet_manager_.receive_algorithm_.reset(
  30       receive_algorithm);
  31 }
  32
  33 // static
  34 void QuicConnectionPeer::SetSendAlgorithm(
  35     QuicConnection* connection,
  36     SendAlgorithmInterface* send_algorithm) {
  37   connection->sent_packet_manager_.send_algorithm_.reset(send_algorithm);
  38 }
  39
  40 // static
  41 QuicAckFrame* QuicConnectionPeer::CreateAckFrame(QuicConnection* connection) {
  42   return connection->CreateAckFrame();
  43 }
  44
  45 // static
  46 QuicStopWaitingFrame* QuicConnectionPeer::CreateStopWaitingFrame(
  47     QuicConnection* connection) {
  48   return connection->CreateStopWaitingFrame();
  49 }
  50
  51 // static
  52 QuicConnectionVisitorInterface* QuicConnectionPeer::GetVisitor(
  53     QuicConnection* connection) {
  54   return connection->visitor_;
  55 }
  56
  57 // static
  58 QuicPacketCreator* QuicConnectionPeer::GetPacketCreator(
  59     QuicConnection* connection) {
  60   return QuicPacketGeneratorPeer::GetPacketCreator(
  61       &connection->packet_generator_);
  62 }
  63
  64 // static
  65 QuicPacketGenerator* QuicConnectionPeer::GetPacketGenerator(
  66     QuicConnection* connection) {
  67   return &connection->packet_generator_;
  68 }
  69
  70 // static
  71 QuicSentPacketManager* QuicConnectionPeer::GetSentPacketManager(
  72     QuicConnection* connection) {
  73   return &connection->sent_packet_manager_;
  74 }
  75
  76 // static
  77 QuicReceivedPacketManager* QuicConnectionPeer::GetReceivedPacketManager(
  78     QuicConnection* connection) {
  79   return &connection->received_packet_manager_;
  80 }
  81
  82 // static
  83 QuicTime::Delta QuicConnectionPeer::GetNetworkTimeout(
  84     QuicConnection* connection) {
  85   return connection->idle_network_timeout_;
  86 }
  87
  88 // static
  89 bool QuicConnectionPeer::IsSavedForRetransmission(
  90     QuicConnection* connection,
  91     QuicPacketSequenceNumber sequence_number) {
  92   return connection->sent_packet_manager_.IsUnacked(sequence_number) &&
  93       connection->sent_packet_manager_.HasRetransmittableFrames(
  94           sequence_number);
  95 }
  96
  97 // static
  98 bool QuicConnectionPeer::IsRetransmission(
  99     QuicConnection* connection,
 100     QuicPacketSequenceNumber sequence_number) {
 101   return QuicSentPacketManagerPeer::IsRetransmission(
 102       &connection->sent_packet_manager_, sequence_number);
 103 }
 104
 105 // static
 106 // TODO(ianswett): Create a GetSentEntropyHash which accepts an AckFrame.
 107 QuicPacketEntropyHash QuicConnectionPeer::GetSentEntropyHash(
 108     QuicConnection* connection,
 109     QuicPacketSequenceNumber sequence_number) {
 110   QuicSentEntropyManager::CumulativeEntropy last_entropy_copy =
 111       connection->sent_entropy_manager_.last_cumulative_entropy_;
 112   connection->sent_entropy_manager_.UpdateCumulativeEntropy(sequence_number,
 113                                                             &last_entropy_copy);
 114   return last_entropy_copy.entropy;
 115 }
 116
 117 // static
 118 QuicPacketEntropyHash QuicConnectionPeer::PacketEntropy(
 119     QuicConnection* connection,
 120     QuicPacketSequenceNumber sequence_number) {
 121   return connection->sent_entropy_manager_.GetPacketEntropy(sequence_number);
 122 }
 123
 124 // static
 125 QuicPacketEntropyHash QuicConnectionPeer::ReceivedEntropyHash(
 126     QuicConnection* connection,
 127     QuicPacketSequenceNumber sequence_number) {
 128   return connection->received_packet_manager_.EntropyHash(
 129       sequence_number);
 130 }
 131
 132 // static
 133 bool QuicConnectionPeer::IsServer(QuicConnection* connection) {
 134   return connection->is_server_;
 135 }
 136
 137 // static
 138 void QuicConnectionPeer::SetIsServer(QuicConnection* connection,
 139                                      bool is_server) {
 140   connection->is_server_ = is_server;
 141   QuicFramerPeer::SetIsServer(&connection->framer_, is_server);
 142 }
 143
 144 // static
 145 void QuicConnectionPeer::SetSelfAddress(QuicConnection* connection,
 146                                         const IPEndPoint& self_address) {
 147   connection->self_address_ = self_address;
 148 }
 149
 150 // static
 151 void QuicConnectionPeer::SetPeerAddress(QuicConnection* connection,
 152                                         const IPEndPoint& peer_address) {
 153   connection->peer_address_ = peer_address;
 154 }
 155
 156 // static
 157 void QuicConnectionPeer::SwapCrypters(QuicConnection* connection,
 158                                       QuicFramer* framer) {
 159   QuicFramerPeer::SwapCrypters(framer, &connection->framer_);
 160 }
 161
 162 // static
 163 QuicConnectionHelperInterface* QuicConnectionPeer::GetHelper(
 164     QuicConnection* connection) {
 165   return connection->helper_;
 166 }
 167
 168 // static
 169 QuicFramer* QuicConnectionPeer::GetFramer(QuicConnection* connection) {
 170   return &connection->framer_;
 171 }
 172
 173 // static
 174 QuicFecGroup* QuicConnectionPeer::GetFecGroup(QuicConnection* connection,
 175                                               int fec_group) {
 176   connection->last_header_.fec_group = fec_group;
 177   return connection->GetFecGroup();
 178 }
 179
 180 // static
 181 QuicAlarm* QuicConnectionPeer::GetAckAlarm(QuicConnection* connection) {
 182   return connection->ack_alarm_.get();
 183 }
 184
 185 // static
 186 QuicAlarm* QuicConnectionPeer::GetPingAlarm(QuicConnection* connection) {
 187   return connection->ping_alarm_.get();
 188 }
 189
 190 // static
 191 QuicAlarm* QuicConnectionPeer::GetResumeWritesAlarm(
 192     QuicConnection* connection) {
 193   return connection->resume_writes_alarm_.get();
 194 }
 195
 196 // static
 197 QuicAlarm* QuicConnectionPeer::GetRetransmissionAlarm(
 198     QuicConnection* connection) {
 199   return connection->retransmission_alarm_.get();
 200 }
 201
 202 // static
 203 QuicAlarm* QuicConnectionPeer::GetSendAlarm(QuicConnection* connection) {
 204   return connection->send_alarm_.get();
 205 }
 206
 207 // static
 208 QuicAlarm* QuicConnectionPeer::GetTimeoutAlarm(QuicConnection* connection) {
 209   return connection->timeout_alarm_.get();
 210 }
 211
 212 // static
 213 QuicPacketWriter* QuicConnectionPeer::GetWriter(QuicConnection* connection) {
 214   return connection->writer_;
 215 }
 216
 217 // static
 218 void QuicConnectionPeer::SetWriter(QuicConnection* connection,
 219                                    QuicPacketWriter* writer,
 220                                    bool owns_writer) {
 221   if (connection->owns_writer_) {
 222     delete connection->writer_;
 223   }
 224   connection->writer_ = writer;
 225   connection->owns_writer_ = owns_writer;
 226 }
 227
 228 // static
 229 void QuicConnectionPeer::CloseConnection(QuicConnection* connection) {
 230   connection->connected_ = false;
 231 }
 232
 233 // static
 234 QuicEncryptedPacket* QuicConnectionPeer::GetConnectionClosePacket(
 235     QuicConnection* connection) {
 236   return connection->connection_close_packet_.get();
 237 }
 238
 239 // static
 240 void QuicConnectionPeer::SetSupportedVersions(QuicConnection* connection,
 241                                               QuicVersionVector versions) {
 242   connection->framer_.SetSupportedVersions(versions);
 243 }
 244
 245 // static
 246 QuicPacketHeader* QuicConnectionPeer::GetLastHeader(
 247     QuicConnection* connection) {
 248   return &connection->last_header_;
 249 }
 250
 251 // static
 252 void QuicConnectionPeer::SetSequenceNumberOfLastSentPacket(
 253     QuicConnection* connection, QuicPacketSequenceNumber number) {
 254   connection->sequence_number_of_last_sent_packet_ = number;
 255 }
 256
 257 }  // namespace test
 258 }  // namespace net