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