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   return connection->sent_entropy_manager_.EntropyHash(sequence_number);
 111 }
 112
 113 // static
 114 bool QuicConnectionPeer::IsValidEntropy(
 115     QuicConnection* connection,
 116     QuicPacketSequenceNumber largest_observed,
 117     const SequenceNumberSet& missing_packets,
 118     QuicPacketEntropyHash entropy_hash) {
 119   return connection->sent_entropy_manager_.IsValidEntropy(
 120       largest_observed, missing_packets, entropy_hash);
 121 }
 122
 123 // static
 124 QuicPacketEntropyHash QuicConnectionPeer::ReceivedEntropyHash(
 125     QuicConnection* connection,
 126     QuicPacketSequenceNumber sequence_number) {
 127   return connection->received_packet_manager_.EntropyHash(
 128       sequence_number);
 129 }
 130
 131 // static
 132 bool QuicConnectionPeer::IsServer(QuicConnection* connection) {
 133   return connection->is_server_;
 134 }
 135
 136 // static
 137 void QuicConnectionPeer::SetIsServer(QuicConnection* connection,
 138                                      bool is_server) {
 139   connection->is_server_ = is_server;
 140   QuicFramerPeer::SetIsServer(&connection->framer_, is_server);
 141 }
 142
 143 // static
 144 void QuicConnectionPeer::SetSelfAddress(QuicConnection* connection,
 145                                         const IPEndPoint& self_address) {
 146   connection->self_address_ = self_address;
 147 }
 148
 149 // static
 150 void QuicConnectionPeer::SetPeerAddress(QuicConnection* connection,
 151                                         const IPEndPoint& peer_address) {
 152   connection->peer_address_ = peer_address;
 153 }
 154
 155 // static
 156 void QuicConnectionPeer::SwapCrypters(QuicConnection* connection,
 157                                       QuicFramer* framer) {
 158   QuicFramerPeer::SwapCrypters(framer, &connection->framer_);
 159 }
 160
 161 // static
 162 QuicConnectionHelperInterface* QuicConnectionPeer::GetHelper(
 163     QuicConnection* connection) {
 164   return connection->helper_;
 165 }
 166
 167 // static
 168 QuicFramer* QuicConnectionPeer::GetFramer(QuicConnection* connection) {
 169   return &connection->framer_;
 170 }
 171
 172 QuicFecGroup* QuicConnectionPeer::GetFecGroup(QuicConnection* connection,
 173                                               int fec_group) {
 174   connection->last_header_.fec_group = fec_group;
 175   return connection->GetFecGroup();
 176 }
 177
 178 // static
 179 QuicAlarm* QuicConnectionPeer::GetAckAlarm(QuicConnection* connection) {
 180   return connection->ack_alarm_.get();
 181 }
 182
 183 // static
 184 QuicAlarm* QuicConnectionPeer::GetPingAlarm(QuicConnection* connection) {
 185   return connection->ping_alarm_.get();
 186 }
 187
 188 // static
 189 QuicAlarm* QuicConnectionPeer::GetResumeWritesAlarm(
 190     QuicConnection* connection) {
 191   return connection->resume_writes_alarm_.get();
 192 }
 193
 194 // static
 195 QuicAlarm* QuicConnectionPeer::GetRetransmissionAlarm(
 196     QuicConnection* connection) {
 197   return connection->retransmission_alarm_.get();
 198 }
 199
 200 // static
 201 QuicAlarm* QuicConnectionPeer::GetSendAlarm(QuicConnection* connection) {
 202   return connection->send_alarm_.get();
 203 }
 204
 205 // static
 206 QuicAlarm* QuicConnectionPeer::GetTimeoutAlarm(QuicConnection* connection) {
 207   return connection->timeout_alarm_.get();
 208 }
 209
 210 // static
 211 QuicPacketWriter* QuicConnectionPeer::GetWriter(QuicConnection* connection) {
 212   return connection->writer_;
 213 }
 214
 215 // static
 216 void QuicConnectionPeer::SetWriter(QuicConnection* connection,
 217                                    QuicPacketWriter* writer,
 218                                    bool owns_writer) {
 219   if (connection->owns_writer_) {
 220     delete connection->writer_;
 221   }
 222   connection->writer_ = writer;
 223   connection->owns_writer_ = owns_writer;
 224 }
 225
 226 // static
 227 void QuicConnectionPeer::CloseConnection(QuicConnection* connection) {
 228   connection->connected_ = false;
 229 }
 230
 231 // static
 232 QuicEncryptedPacket* QuicConnectionPeer::GetConnectionClosePacket(
 233     QuicConnection* connection) {
 234   return connection->connection_close_packet_.get();
 235 }
 236
 237 // static
 238 void QuicConnectionPeer::SetSupportedVersions(QuicConnection* connection,
 239                                               QuicVersionVector versions) {
 240   connection->framer_.SetSupportedVersions(versions);
 241 }
 242
 243 }  // namespace test
 244 }  // namespace net