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