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 #ifndef QUICHE_QUIC_TEST_TOOLS_QUIC_CONNECTION_PEER_H_
6 #define QUICHE_QUIC_TEST_TOOLS_QUIC_CONNECTION_PEER_H_
7 
8 #include "absl/strings/string_view.h"
9 #include "net/third_party/quiche/src/quic/core/quic_connection.h"
10 #include "net/third_party/quiche/src/quic/core/quic_connection_stats.h"
11 #include "net/third_party/quiche/src/quic/core/quic_packets.h"
12 #include "net/third_party/quiche/src/quic/platform/api/quic_socket_address.h"
13 
14 namespace quic {
15 
16 struct QuicPacketHeader;
17 class QuicAlarm;
18 class QuicConnectionHelperInterface;
19 class QuicConnectionVisitorInterface;
20 class QuicEncryptedPacket;
21 class QuicFramer;
22 class QuicPacketCreator;
23 class QuicPacketWriter;
24 class QuicSentPacketManager;
25 class SendAlgorithmInterface;
26 
27 namespace test {
28 
29 // Peer to make public a number of otherwise private QuicConnection methods.
30 class QuicConnectionPeer {
31  public:
32   QuicConnectionPeer() = delete;
33 
34   static void SetSendAlgorithm(QuicConnection* connection,
35                                SendAlgorithmInterface* send_algorithm);
36 
37   static void SetLossAlgorithm(QuicConnection* connection,
38                                LossDetectionInterface* loss_algorithm);
39 
40   static void PopulateStopWaitingFrame(QuicConnection* connection,
41                                        QuicStopWaitingFrame* stop_waiting);
42 
43   static QuicPacketCreator* GetPacketCreator(QuicConnection* connection);
44 
45   static QuicSentPacketManager* GetSentPacketManager(
46       QuicConnection* connection);
47 
48   static QuicTime::Delta GetNetworkTimeout(QuicConnection* connection);
49 
50   static void SetPerspective(QuicConnection* connection,
51                              Perspective perspective);
52 
53   static void SetSelfAddress(QuicConnection* connection,
54                              const QuicSocketAddress& self_address);
55 
56   static void SetPeerAddress(QuicConnection* connection,
57                              const QuicSocketAddress& peer_address);
58 
59   static void SetDirectPeerAddress(
60       QuicConnection* connection,
61       const QuicSocketAddress& direct_peer_address);
62 
63   static void SetEffectivePeerAddress(
64       QuicConnection* connection,
65       const QuicSocketAddress& effective_peer_address);
66 
67   static void SwapCrypters(QuicConnection* connection, QuicFramer* framer);
68 
69   static void SetCurrentPacket(QuicConnection* connection,
70                                absl::string_view current_packet);
71 
72   static QuicConnectionHelperInterface* GetHelper(QuicConnection* connection);
73 
74   static QuicAlarmFactory* GetAlarmFactory(QuicConnection* connection);
75 
76   static QuicFramer* GetFramer(QuicConnection* connection);
77 
78   static QuicAlarm* GetAckAlarm(QuicConnection* connection);
79   static QuicAlarm* GetPingAlarm(QuicConnection* connection);
80   static QuicAlarm* GetRetransmissionAlarm(QuicConnection* connection);
81   static QuicAlarm* GetSendAlarm(QuicConnection* connection);
82   static QuicAlarm* GetMtuDiscoveryAlarm(QuicConnection* connection);
83   static QuicAlarm* GetProcessUndecryptablePacketsAlarm(
84       QuicConnection* connection);
85   static QuicAlarm* GetDiscardPreviousOneRttKeysAlarm(
86       QuicConnection* connection);
87 
88   static QuicPacketWriter* GetWriter(QuicConnection* connection);
89   // If |owns_writer| is true, takes ownership of |writer|.
90   static void SetWriter(QuicConnection* connection,
91                         QuicPacketWriter* writer,
92                         bool owns_writer);
93   static void TearDownLocalConnectionState(QuicConnection* connection);
94   static QuicEncryptedPacket* GetConnectionClosePacket(
95       QuicConnection* connection);
96 
97   static QuicPacketHeader* GetLastHeader(QuicConnection* connection);
98 
99   static QuicConnectionStats* GetStats(QuicConnection* connection);
100 
101   static QuicPacketCount GetPacketsBetweenMtuProbes(QuicConnection* connection);
102 
103   static void ReInitializeMtuDiscoverer(
104       QuicConnection* connection,
105       QuicPacketCount packets_between_probes_base,
106       QuicPacketNumber next_probe_at);
107   static void SetAckDecimationDelay(QuicConnection* connection,
108                                     float ack_decimation_delay);
109   static bool HasRetransmittableFrames(QuicConnection* connection,
110                                        uint64_t packet_number);
111   static bool GetNoStopWaitingFrames(QuicConnection* connection);
112   static void SetNoStopWaitingFrames(QuicConnection* connection,
113                                      bool no_stop_waiting_frames);
114   static void SetMaxTrackedPackets(QuicConnection* connection,
115                                    QuicPacketCount max_tracked_packets);
116   static void SetNegotiatedVersion(QuicConnection* connection);
117   static void SetMaxConsecutiveNumPacketsWithNoRetransmittableFrames(
118       QuicConnection* connection,
119       size_t new_value);
120   static bool SupportsReleaseTime(QuicConnection* connection);
121   static QuicConnection::PacketContent GetCurrentPacketContent(
122       QuicConnection* connection);
123   static void SetLastHeaderFormat(QuicConnection* connection,
124                                   PacketHeaderFormat format);
125   static void AddBytesReceived(QuicConnection* connection, size_t length);
126   static void SetAddressValidated(QuicConnection* connection);
127   static void SetEnableAeadLimits(QuicConnection* connection, bool enabled);
128 
129   static void SendConnectionClosePacket(QuicConnection* connection,
130                                         QuicErrorCode error,
131                                         const std::string& details);
132 
133   static size_t GetNumEncryptionLevels(QuicConnection* connection);
134 
135   static QuicNetworkBlackholeDetector& GetBlackholeDetector(
136       QuicConnection* connection);
137 
138   static QuicAlarm* GetBlackholeDetectorAlarm(QuicConnection* connection);
139 
140   static QuicTime GetPathDegradingDeadline(QuicConnection* connection);
141 
142   static QuicTime GetBlackholeDetectionDeadline(QuicConnection* connection);
143 
144   static QuicTime GetPathMtuReductionDetectionDeadline(
145       QuicConnection* connection);
146 
147   static QuicAlarm* GetIdleNetworkDetectorAlarm(QuicConnection* connection);
148 
149   static QuicTime GetIdleNetworkDeadline(QuicConnection* connection);
150 
151   static QuicIdleNetworkDetector& GetIdleNetworkDetector(
152       QuicConnection* connection);
153 
154   static void SetServerConnectionId(
155       QuicConnection* connection,
156       const QuicConnectionId& server_connection_id);
157 
158   static size_t NumUndecryptablePackets(QuicConnection* connection);
159 
160   static const QuicCircularDeque<
161       std::pair<QuicPathFrameBuffer, QuicSocketAddress>>&
162   pending_path_challenge_payloads(QuicConnection* connection);
163 
164   static void SetConnectionClose(QuicConnection* connection);
165 
166   static void SendPing(QuicConnection* connection);
167 };
168 
169 }  // namespace test
170 
171 }  // namespace quic
172 
173 #endif  // QUICHE_QUIC_TEST_TOOLS_QUIC_CONNECTION_PEER_H_
174