quic_connection_peer.cc revision 03b57e008b61dfcb1fbad3aea950ae0e001748b0
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 17namespace net { 18namespace test { 19 20// static 21void QuicConnectionPeer::SendAck(QuicConnection* connection) { 22 connection->SendAck(); 23} 24 25// static 26void QuicConnectionPeer::SetReceiveAlgorithm( 27 QuicConnection* connection, 28 ReceiveAlgorithmInterface* receive_algorithm) { 29 connection->received_packet_manager_.receive_algorithm_.reset( 30 receive_algorithm); 31} 32 33// static 34void QuicConnectionPeer::SetSendAlgorithm( 35 QuicConnection* connection, 36 SendAlgorithmInterface* send_algorithm) { 37 connection->sent_packet_manager_.send_algorithm_.reset(send_algorithm); 38} 39 40// static 41QuicAckFrame* QuicConnectionPeer::CreateAckFrame(QuicConnection* connection) { 42 return connection->CreateAckFrame(); 43} 44 45// static 46QuicStopWaitingFrame* QuicConnectionPeer::CreateStopWaitingFrame( 47 QuicConnection* connection) { 48 return connection->CreateStopWaitingFrame(); 49} 50 51// static 52QuicConnectionVisitorInterface* QuicConnectionPeer::GetVisitor( 53 QuicConnection* connection) { 54 return connection->visitor_; 55} 56 57// static 58QuicPacketCreator* QuicConnectionPeer::GetPacketCreator( 59 QuicConnection* connection) { 60 return QuicPacketGeneratorPeer::GetPacketCreator( 61 &connection->packet_generator_); 62} 63 64// static 65QuicPacketGenerator* QuicConnectionPeer::GetPacketGenerator( 66 QuicConnection* connection) { 67 return &connection->packet_generator_; 68} 69 70// static 71QuicSentPacketManager* QuicConnectionPeer::GetSentPacketManager( 72 QuicConnection* connection) { 73 return &connection->sent_packet_manager_; 74} 75 76// static 77QuicReceivedPacketManager* QuicConnectionPeer::GetReceivedPacketManager( 78 QuicConnection* connection) { 79 return &connection->received_packet_manager_; 80} 81 82// static 83QuicTime::Delta QuicConnectionPeer::GetNetworkTimeout( 84 QuicConnection* connection) { 85 return connection->idle_network_timeout_; 86} 87 88// static 89bool 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 98bool 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. 107QuicPacketEntropyHash 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 118QuicPacketEntropyHash QuicConnectionPeer::PacketEntropy( 119 QuicConnection* connection, 120 QuicPacketSequenceNumber sequence_number) { 121 return connection->sent_entropy_manager_.GetPacketEntropy(sequence_number); 122} 123 124// static 125QuicPacketEntropyHash QuicConnectionPeer::ReceivedEntropyHash( 126 QuicConnection* connection, 127 QuicPacketSequenceNumber sequence_number) { 128 return connection->received_packet_manager_.EntropyHash( 129 sequence_number); 130} 131 132// static 133bool QuicConnectionPeer::IsServer(QuicConnection* connection) { 134 return connection->is_server_; 135} 136 137// static 138void 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 145void QuicConnectionPeer::SetSelfAddress(QuicConnection* connection, 146 const IPEndPoint& self_address) { 147 connection->self_address_ = self_address; 148} 149 150// static 151void QuicConnectionPeer::SetPeerAddress(QuicConnection* connection, 152 const IPEndPoint& peer_address) { 153 connection->peer_address_ = peer_address; 154} 155 156// static 157void QuicConnectionPeer::SwapCrypters(QuicConnection* connection, 158 QuicFramer* framer) { 159 QuicFramerPeer::SwapCrypters(framer, &connection->framer_); 160} 161 162// static 163QuicConnectionHelperInterface* QuicConnectionPeer::GetHelper( 164 QuicConnection* connection) { 165 return connection->helper_; 166} 167 168// static 169QuicFramer* QuicConnectionPeer::GetFramer(QuicConnection* connection) { 170 return &connection->framer_; 171} 172 173// static 174QuicFecGroup* QuicConnectionPeer::GetFecGroup(QuicConnection* connection, 175 int fec_group) { 176 connection->last_header_.fec_group = fec_group; 177 return connection->GetFecGroup(); 178} 179 180// static 181QuicAlarm* QuicConnectionPeer::GetAckAlarm(QuicConnection* connection) { 182 return connection->ack_alarm_.get(); 183} 184 185// static 186QuicAlarm* QuicConnectionPeer::GetPingAlarm(QuicConnection* connection) { 187 return connection->ping_alarm_.get(); 188} 189 190// static 191QuicAlarm* QuicConnectionPeer::GetResumeWritesAlarm( 192 QuicConnection* connection) { 193 return connection->resume_writes_alarm_.get(); 194} 195 196// static 197QuicAlarm* QuicConnectionPeer::GetRetransmissionAlarm( 198 QuicConnection* connection) { 199 return connection->retransmission_alarm_.get(); 200} 201 202// static 203QuicAlarm* QuicConnectionPeer::GetSendAlarm(QuicConnection* connection) { 204 return connection->send_alarm_.get(); 205} 206 207// static 208QuicAlarm* QuicConnectionPeer::GetTimeoutAlarm(QuicConnection* connection) { 209 return connection->timeout_alarm_.get(); 210} 211 212// static 213QuicPacketWriter* QuicConnectionPeer::GetWriter(QuicConnection* connection) { 214 return connection->writer_; 215} 216 217// static 218void 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 229void QuicConnectionPeer::CloseConnection(QuicConnection* connection) { 230 connection->connected_ = false; 231} 232 233// static 234QuicEncryptedPacket* QuicConnectionPeer::GetConnectionClosePacket( 235 QuicConnection* connection) { 236 return connection->connection_close_packet_.get(); 237} 238 239// static 240void QuicConnectionPeer::SetSupportedVersions(QuicConnection* connection, 241 QuicVersionVector versions) { 242 connection->framer_.SetSupportedVersions(versions); 243} 244 245} // namespace test 246} // namespace net 247