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