Home | History | Annotate | Download | only in test_tools 
      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/quic_congestion_manager.h"
      9 #include "net/quic/congestion_control/receive_algorithm_interface.h"
     10 #include "net/quic/congestion_control/send_algorithm_interface.h"
     11 #include "net/quic/quic_connection.h"
     12 #include "net/quic/test_tools/quic_framer_peer.h"
     13 
     14 namespace net {
     15 namespace test {
     16 
     17 // static
     18 void QuicConnectionPeer::SendAck(QuicConnection* connection) {
     19   connection->SendAck();
     20 }
     21 
     22 // static
     23 void QuicConnectionPeer::SetReceiveAlgorithm(
     24     QuicConnection* connection,
     25     ReceiveAlgorithmInterface* receive_algorithm) {
     26   connection->congestion_manager_.receive_algorithm_.reset(receive_algorithm);
     27 }
     28 
     29 // static
     30 void QuicConnectionPeer::SetSendAlgorithm(
     31     QuicConnection* connection,
     32     SendAlgorithmInterface* send_algorithm) {
     33   connection->congestion_manager_.send_algorithm_.reset(send_algorithm);
     34 }
     35 
     36 // static
     37 QuicAckFrame* QuicConnectionPeer::CreateAckFrame(QuicConnection* connection) {
     38   return connection->CreateAckFrame();
     39 }
     40 
     41 // static
     42 QuicConnectionVisitorInterface* QuicConnectionPeer::GetVisitor(
     43     QuicConnection* connection) {
     44   return connection->visitor_;
     45 }
     46 
     47 // static
     48 QuicPacketCreator* QuicConnectionPeer::GetPacketCreator(
     49     QuicConnection* connection) {
     50   return &connection->packet_creator_;
     51 }
     52 
     53 bool QuicConnectionPeer::GetReceivedTruncatedAck(QuicConnection* connection) {
     54     return connection->received_truncated_ack_;
     55 }
     56 
     57 // static
     58 size_t QuicConnectionPeer::GetNumRetransmissionTimeouts(
     59     QuicConnection* connection) {
     60   return connection->retransmission_timeouts_.size();
     61 }
     62 
     63 // static
     64 QuicTime::Delta QuicConnectionPeer::GetNetworkTimeout(
     65     QuicConnection* connection) {
     66   return connection->idle_network_timeout_;
     67 }
     68 
     69 // static
     70 bool QuicConnectionPeer::IsSavedForRetransmission(
     71     QuicConnection* connection,
     72     QuicPacketSequenceNumber sequence_number) {
     73   return ContainsKey(connection->retransmission_map_, sequence_number);
     74 }
     75 
     76 // static
     77 size_t QuicConnectionPeer::GetRetransmissionCount(
     78     QuicConnection* connection,
     79     QuicPacketSequenceNumber sequence_number) {
     80   QuicConnection::RetransmissionMap::iterator it =
     81       connection->retransmission_map_.find(sequence_number);
     82   DCHECK(connection->retransmission_map_.end() != it);
     83   return it->second.number_retransmissions;
     84 }
     85 
     86 // static
     87 QuicPacketEntropyHash QuicConnectionPeer::GetSentEntropyHash(
     88     QuicConnection* connection,
     89     QuicPacketSequenceNumber sequence_number) {
     90   return connection->sent_entropy_manager_.EntropyHash(sequence_number);
     91 }
     92 
     93 // static
     94 bool QuicConnectionPeer::IsValidEntropy(
     95     QuicConnection* connection,
     96     QuicPacketSequenceNumber largest_observed,
     97     const SequenceNumberSet& missing_packets,
     98     QuicPacketEntropyHash entropy_hash) {
     99   return connection->sent_entropy_manager_.IsValidEntropy(
    100       largest_observed, missing_packets, entropy_hash);
    101 }
    102 
    103 // static
    104 QuicPacketEntropyHash QuicConnectionPeer::ReceivedEntropyHash(
    105     QuicConnection* connection,
    106     QuicPacketSequenceNumber sequence_number) {
    107   return connection->received_packet_manager_.EntropyHash(
    108       sequence_number);
    109 }
    110 
    111 // static
    112 bool QuicConnectionPeer::IsServer(QuicConnection* connection) {
    113   return connection->is_server_;
    114 }
    115 
    116 // static
    117 void QuicConnectionPeer::SetIsServer(QuicConnection* connection,
    118                                      bool is_server) {
    119   connection->is_server_ = is_server;
    120   QuicFramerPeer::SetIsServer(&connection->framer_, is_server);
    121 }
    122 
    123 // static
    124 void QuicConnectionPeer::SetSelfAddress(QuicConnection* connection,
    125                                         const IPEndPoint& self_address) {
    126   connection->self_address_ = self_address;
    127 }
    128 
    129 // static
    130 void QuicConnectionPeer::SwapCrypters(QuicConnection* connection,
    131                                       QuicFramer* framer) {
    132   framer->SwapCryptersForTest(&connection->framer_);
    133 }
    134 
    135 // static
    136 void QuicConnectionPeer:: SetMaxPacketsPerRetransmissionAlarm(
    137     QuicConnection* connection,
    138     int max_packets) {
    139   connection->max_packets_per_retransmission_alarm_ = max_packets;
    140 }
    141 
    142 // static
    143 QuicConnectionHelperInterface* QuicConnectionPeer::GetHelper(
    144     QuicConnection* connection) {
    145   return connection->helper_.get();
    146 }
    147 
    148 // static
    149 QuicFramer* QuicConnectionPeer::GetFramer(QuicConnection* connection) {
    150   return &connection->framer_;
    151 }
    152 
    153 QuicFecGroup* QuicConnectionPeer::GetFecGroup(QuicConnection* connection,
    154                                               int fec_group) {
    155   connection->last_header_.fec_group = fec_group;
    156   return connection->GetFecGroup();
    157 }
    158 
    159 // static
    160 QuicAlarm* QuicConnectionPeer::GetAckAlarm(QuicConnection* connection) {
    161   return connection->ack_alarm_.get();
    162 }
    163 
    164 // static
    165 QuicAlarm* QuicConnectionPeer::GetRetransmissionAlarm(
    166     QuicConnection* connection) {
    167   return connection->retransmission_alarm_.get();
    168 }
    169 
    170 // static
    171 QuicAlarm* QuicConnectionPeer::GetSendAlarm(QuicConnection* connection) {
    172   return connection->send_alarm_.get();
    173 }
    174 
    175 // static
    176 QuicAlarm* QuicConnectionPeer::GetTimeoutAlarm(QuicConnection* connection) {
    177   return connection->timeout_alarm_.get();
    178 }
    179 
    180 }  // namespace test
    181 }  // namespace net
    182