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_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::SetReceiveAlgorithm(
  26     QuicConnection* connection,
  27     ReceiveAlgorithmInterface* receive_algorithm) {
  28   connection->received_packet_manager_.receive_algorithm_.reset(
  29       receive_algorithm);
  30 }
  31
  32 // static
  33 void QuicConnectionPeer::SetSendAlgorithm(
  34     QuicConnection* connection,
  35     SendAlgorithmInterface* send_algorithm) {
  36   connection->sent_packet_manager_.send_algorithm_.reset(send_algorithm);
  37 }
  38
  39 // static
  40 QuicAckFrame* QuicConnectionPeer::CreateAckFrame(QuicConnection* connection) {
  41   return connection->CreateAckFrame();
  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 &connection->packet_creator_;
  54 }
  55
  56 // static
  57 QuicSentPacketManager* QuicConnectionPeer::GetSentPacketManager(
  58     QuicConnection* connection) {
  59   return &connection->sent_packet_manager_;
  60 }
  61
  62 // static
  63 QuicReceivedPacketManager* QuicConnectionPeer::GetReceivedPacketManager(
  64     QuicConnection* connection) {
  65   return &connection->received_packet_manager_;
  66 }
  67
  68 // static
  69 QuicTime::Delta QuicConnectionPeer::GetNetworkTimeout(
  70     QuicConnection* connection) {
  71   return connection->idle_network_timeout_;
  72 }
  73
  74 // static
  75 bool QuicConnectionPeer::IsSavedForRetransmission(
  76     QuicConnection* connection,
  77     QuicPacketSequenceNumber sequence_number) {
  78   return connection->sent_packet_manager_.IsUnacked(sequence_number) &&
  79       connection->sent_packet_manager_.HasRetransmittableFrames(
  80           sequence_number);
  81 }
  82
  83 // static
  84 bool QuicConnectionPeer::IsRetransmission(
  85     QuicConnection* connection,
  86     QuicPacketSequenceNumber sequence_number) {
  87   return QuicSentPacketManagerPeer::IsRetransmission(
  88       &connection->sent_packet_manager_, sequence_number);
  89 }
  90
  91 // static
  92 // TODO(ianswett): Create a GetSentEntropyHash which accepts an AckFrame.
  93 QuicPacketEntropyHash QuicConnectionPeer::GetSentEntropyHash(
  94     QuicConnection* connection,
  95     QuicPacketSequenceNumber sequence_number) {
  96   return connection->sent_entropy_manager_.EntropyHash(sequence_number);
  97 }
  98
  99 // static
 100 bool QuicConnectionPeer::IsValidEntropy(
 101     QuicConnection* connection,
 102     QuicPacketSequenceNumber largest_observed,
 103     const SequenceNumberSet& missing_packets,
 104     QuicPacketEntropyHash entropy_hash) {
 105   return connection->sent_entropy_manager_.IsValidEntropy(
 106       largest_observed, missing_packets, entropy_hash);
 107 }
 108
 109 // static
 110 QuicPacketEntropyHash QuicConnectionPeer::ReceivedEntropyHash(
 111     QuicConnection* connection,
 112     QuicPacketSequenceNumber sequence_number) {
 113   return connection->received_packet_manager_.EntropyHash(
 114       sequence_number);
 115 }
 116
 117 // static
 118 bool QuicConnectionPeer::IsServer(QuicConnection* connection) {
 119   return connection->is_server_;
 120 }
 121
 122 // static
 123 void QuicConnectionPeer::SetIsServer(QuicConnection* connection,
 124                                      bool is_server) {
 125   connection->is_server_ = is_server;
 126   QuicFramerPeer::SetIsServer(&connection->framer_, is_server);
 127 }
 128
 129 // static
 130 void QuicConnectionPeer::SetSelfAddress(QuicConnection* connection,
 131                                         const IPEndPoint& self_address) {
 132   connection->self_address_ = self_address;
 133 }
 134
 135 // static
 136 void QuicConnectionPeer::SetPeerAddress(QuicConnection* connection,
 137                                         const IPEndPoint& peer_address) {
 138   connection->peer_address_ = peer_address;
 139 }
 140
 141 // static
 142 void QuicConnectionPeer::SwapCrypters(QuicConnection* connection,
 143                                       QuicFramer* framer) {
 144   QuicFramerPeer::SwapCrypters(framer, &connection->framer_);
 145 }
 146
 147 // static
 148 QuicConnectionHelperInterface* QuicConnectionPeer::GetHelper(
 149     QuicConnection* connection) {
 150   return connection->helper_;
 151 }
 152
 153 // static
 154 QuicFramer* QuicConnectionPeer::GetFramer(QuicConnection* connection) {
 155   return &connection->framer_;
 156 }
 157
 158 QuicFecGroup* QuicConnectionPeer::GetFecGroup(QuicConnection* connection,
 159                                               int fec_group) {
 160   connection->last_header_.fec_group = fec_group;
 161   return connection->GetFecGroup();
 162 }
 163
 164 // static
 165 QuicAlarm* QuicConnectionPeer::GetAckAlarm(QuicConnection* connection) {
 166   return connection->ack_alarm_.get();
 167 }
 168
 169 // static
 170 QuicAlarm* QuicConnectionPeer::GetPingAlarm(QuicConnection* connection) {
 171   return connection->ping_alarm_.get();
 172 }
 173
 174 // static
 175 QuicAlarm* QuicConnectionPeer::GetResumeWritesAlarm(
 176     QuicConnection* connection) {
 177   return connection->resume_writes_alarm_.get();
 178 }
 179
 180 // static
 181 QuicAlarm* QuicConnectionPeer::GetRetransmissionAlarm(
 182     QuicConnection* connection) {
 183   return connection->retransmission_alarm_.get();
 184 }
 185
 186 // static
 187 QuicAlarm* QuicConnectionPeer::GetSendAlarm(QuicConnection* connection) {
 188   return connection->send_alarm_.get();
 189 }
 190
 191 // static
 192 QuicAlarm* QuicConnectionPeer::GetTimeoutAlarm(QuicConnection* connection) {
 193   return connection->timeout_alarm_.get();
 194 }
 195
 196 // static
 197 QuicPacketWriter* QuicConnectionPeer::GetWriter(QuicConnection* connection) {
 198   return connection->writer_;
 199 }
 200
 201 // static
 202 void QuicConnectionPeer::SetWriter(QuicConnection* connection,
 203                                    QuicPacketWriter* writer) {
 204   connection->writer_ = writer;
 205 }
 206
 207 // static
 208 void QuicConnectionPeer::CloseConnection(QuicConnection* connection) {
 209   connection->connected_ = false;
 210 }
 211
 212 // static
 213 QuicEncryptedPacket* QuicConnectionPeer::GetConnectionClosePacket(
 214     QuicConnection* connection) {
 215   return connection->connection_close_packet_.get();
 216 }
 217
 218 }  // namespace test
 219 }  // namespace net