OLD | NEW |
| (Empty) |
1 // Copyright 2013 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 // Provides a simple interface for QUIC tests to create a variety of packets. | |
6 | |
7 #ifndef NET_QUIC_TEST_TOOLS_QUIC_TEST_PACKET_MAKER_H_ | |
8 #define NET_QUIC_TEST_TOOLS_QUIC_TEST_PACKET_MAKER_H_ | |
9 | |
10 #include <stddef.h> | |
11 | |
12 #include <memory> | |
13 #include <string> | |
14 #include <vector> | |
15 | |
16 #include "base/macros.h" | |
17 #include "net/base/request_priority.h" | |
18 #include "net/quic/core/quic_packets.h" | |
19 #include "net/quic/test_tools/mock_clock.h" | |
20 #include "net/quic/test_tools/mock_random.h" | |
21 #include "net/spdy/spdy_framer.h" | |
22 #include "net/spdy/spdy_protocol.h" | |
23 | |
24 namespace net { | |
25 namespace test { | |
26 | |
27 class QuicTestPacketMaker { | |
28 public: | |
29 QuicTestPacketMaker(QuicVersion version, | |
30 QuicConnectionId connection_id, | |
31 MockClock* clock, | |
32 const std::string& host, | |
33 Perspective perspective); | |
34 ~QuicTestPacketMaker(); | |
35 | |
36 void set_hostname(const std::string& host); | |
37 std::unique_ptr<QuicReceivedPacket> MakePingPacket(QuicPacketNumber num, | |
38 bool include_version); | |
39 std::unique_ptr<QuicReceivedPacket> MakeRstPacket( | |
40 QuicPacketNumber num, | |
41 bool include_version, | |
42 QuicStreamId stream_id, | |
43 QuicRstStreamErrorCode error_code); | |
44 | |
45 std::unique_ptr<QuicReceivedPacket> MakeRstPacket( | |
46 QuicPacketNumber num, | |
47 bool include_version, | |
48 QuicStreamId stream_id, | |
49 QuicRstStreamErrorCode error_code, | |
50 size_t bytes_written); | |
51 | |
52 std::unique_ptr<QuicReceivedPacket> MakeAckAndRstPacket( | |
53 QuicPacketNumber num, | |
54 bool include_version, | |
55 QuicStreamId stream_id, | |
56 QuicRstStreamErrorCode error_code, | |
57 QuicPacketNumber largest_received, | |
58 QuicPacketNumber ack_least_unacked, | |
59 QuicPacketNumber stop_least_unacked, | |
60 bool send_feedback); | |
61 std::unique_ptr<QuicReceivedPacket> MakeAckAndConnectionClosePacket( | |
62 QuicPacketNumber num, | |
63 bool include_version, | |
64 QuicTime::Delta delta_time_largest_observed, | |
65 QuicPacketNumber largest_received, | |
66 QuicPacketNumber least_unacked, | |
67 QuicErrorCode quic_error, | |
68 const std::string& quic_error_details); | |
69 std::unique_ptr<QuicReceivedPacket> MakeConnectionClosePacket( | |
70 QuicPacketNumber num); | |
71 std::unique_ptr<QuicReceivedPacket> MakeGoAwayPacket( | |
72 QuicPacketNumber num, | |
73 QuicErrorCode error_code, | |
74 std::string reason_phrase); | |
75 std::unique_ptr<QuicReceivedPacket> MakeAckPacket( | |
76 QuicPacketNumber packet_number, | |
77 QuicPacketNumber largest_received, | |
78 QuicPacketNumber least_unacked, | |
79 bool send_feedback); | |
80 std::unique_ptr<QuicReceivedPacket> MakeAckPacket( | |
81 QuicPacketNumber packet_number, | |
82 QuicPacketNumber largest_received, | |
83 QuicPacketNumber ack_least_unacked, | |
84 QuicPacketNumber stop_least_unacked, | |
85 bool send_feedback); | |
86 std::unique_ptr<QuicReceivedPacket> MakeDataPacket( | |
87 QuicPacketNumber packet_number, | |
88 QuicStreamId stream_id, | |
89 bool should_include_version, | |
90 bool fin, | |
91 QuicStreamOffset offset, | |
92 base::StringPiece data); | |
93 std::unique_ptr<QuicReceivedPacket> MakeForceHolDataPacket( | |
94 QuicPacketNumber packet_number, | |
95 QuicStreamId stream_id, | |
96 bool should_include_version, | |
97 bool fin, | |
98 QuicStreamOffset* offset, | |
99 base::StringPiece data); | |
100 std::unique_ptr<QuicReceivedPacket> MakeMultipleDataFramesPacket( | |
101 QuicPacketNumber packet_number, | |
102 QuicStreamId stream_id, | |
103 bool should_include_version, | |
104 bool fin, | |
105 QuicStreamOffset offset, | |
106 const std::vector<std::string>& data_writes); | |
107 std::unique_ptr<QuicReceivedPacket> MakeAckAndDataPacket( | |
108 QuicPacketNumber packet_number, | |
109 bool include_version, | |
110 QuicStreamId stream_id, | |
111 QuicPacketNumber largest_received, | |
112 QuicPacketNumber least_unacked, | |
113 bool fin, | |
114 QuicStreamOffset offset, | |
115 base::StringPiece data); | |
116 | |
117 std::unique_ptr<QuicReceivedPacket> | |
118 MakeRequestHeadersAndMultipleDataFramesPacket( | |
119 QuicPacketNumber packet_number, | |
120 QuicStreamId stream_id, | |
121 bool should_include_version, | |
122 bool fin, | |
123 SpdyPriority priority, | |
124 SpdyHeaderBlock headers, | |
125 QuicStreamOffset* header_stream_offset, | |
126 size_t* spdy_headers_frame_length, | |
127 const std::vector<std::string>& data_writes); | |
128 | |
129 // If |spdy_headers_frame_length| is non-null, it will be set to the size of | |
130 // the SPDY headers frame created for this packet. | |
131 std::unique_ptr<QuicReceivedPacket> MakeRequestHeadersPacket( | |
132 QuicPacketNumber packet_number, | |
133 QuicStreamId stream_id, | |
134 bool should_include_version, | |
135 bool fin, | |
136 SpdyPriority priority, | |
137 SpdyHeaderBlock headers, | |
138 size_t* spdy_headers_frame_length); | |
139 | |
140 std::unique_ptr<QuicReceivedPacket> MakeRequestHeadersPacket( | |
141 QuicPacketNumber packet_number, | |
142 QuicStreamId stream_id, | |
143 bool should_include_version, | |
144 bool fin, | |
145 SpdyPriority priority, | |
146 SpdyHeaderBlock headers, | |
147 size_t* spdy_headers_frame_length, | |
148 QuicStreamOffset* offset); | |
149 | |
150 // Convenience method for calling MakeRequestHeadersPacket with nullptr for | |
151 // |spdy_headers_frame_length|. | |
152 std::unique_ptr<QuicReceivedPacket> | |
153 MakeRequestHeadersPacketWithOffsetTracking(QuicPacketNumber packet_number, | |
154 QuicStreamId stream_id, | |
155 bool should_include_version, | |
156 bool fin, | |
157 SpdyPriority priority, | |
158 SpdyHeaderBlock headers, | |
159 QuicStreamOffset* offset); | |
160 | |
161 // If |spdy_headers_frame_length| is non-null, it will be set to the size of | |
162 // the SPDY headers frame created for this packet. | |
163 std::unique_ptr<QuicReceivedPacket> MakePushPromisePacket( | |
164 QuicPacketNumber packet_number, | |
165 QuicStreamId stream_id, | |
166 QuicStreamId promised_stream_id, | |
167 bool should_include_version, | |
168 bool fin, | |
169 SpdyHeaderBlock headers, | |
170 size_t* spdy_headers_frame_length, | |
171 QuicStreamOffset* offset); | |
172 | |
173 // If |spdy_headers_frame_length| is non-null, it will be set to the size of | |
174 // the SPDY headers frame created for this packet. | |
175 std::unique_ptr<QuicReceivedPacket> MakeResponseHeadersPacket( | |
176 QuicPacketNumber packet_number, | |
177 QuicStreamId stream_id, | |
178 bool should_include_version, | |
179 bool fin, | |
180 SpdyHeaderBlock headers, | |
181 size_t* spdy_headers_frame_length, | |
182 QuicStreamOffset* offset); | |
183 | |
184 std::unique_ptr<QuicReceivedPacket> MakeResponseHeadersPacket( | |
185 QuicPacketNumber packet_number, | |
186 QuicStreamId stream_id, | |
187 bool should_include_version, | |
188 bool fin, | |
189 SpdyHeaderBlock headers, | |
190 size_t* spdy_headers_frame_length); | |
191 | |
192 // Convenience method for calling MakeResponseHeadersPacket with nullptr for | |
193 // |spdy_headers_frame_length|. | |
194 std::unique_ptr<QuicReceivedPacket> | |
195 MakeResponseHeadersPacketWithOffsetTracking(QuicPacketNumber packet_number, | |
196 QuicStreamId stream_id, | |
197 bool should_include_version, | |
198 bool fin, | |
199 SpdyHeaderBlock headers, | |
200 QuicStreamOffset* offset); | |
201 | |
202 std::unique_ptr<QuicReceivedPacket> MakeSettingsPacket( | |
203 QuicPacketNumber packet_number, | |
204 SpdySettingsIds id, | |
205 size_t value, | |
206 bool should_include_version, | |
207 QuicStreamOffset* offset); | |
208 | |
209 SpdyHeaderBlock GetRequestHeaders(const std::string& method, | |
210 const std::string& scheme, | |
211 const std::string& path); | |
212 SpdyHeaderBlock GetResponseHeaders(const std::string& status); | |
213 | |
214 SpdyHeaderBlock GetResponseHeaders(const std::string& status, | |
215 const std::string& alt_svc); | |
216 | |
217 private: | |
218 std::unique_ptr<QuicReceivedPacket> MakePacket(const QuicPacketHeader& header, | |
219 const QuicFrame& frame); | |
220 std::unique_ptr<QuicReceivedPacket> MakeMultipleFramesPacket( | |
221 const QuicPacketHeader& header, | |
222 const QuicFrames& frames); | |
223 | |
224 void InitializeHeader(QuicPacketNumber packet_number, | |
225 bool should_include_version); | |
226 | |
227 QuicVersion version_; | |
228 QuicConnectionId connection_id_; | |
229 MockClock* clock_; // Owned by QuicStreamFactory. | |
230 std::string host_; | |
231 SpdyFramer spdy_request_framer_; | |
232 SpdyFramer spdy_response_framer_; | |
233 MockRandom random_generator_; | |
234 QuicPacketHeader header_; | |
235 Perspective perspective_; | |
236 | |
237 DISALLOW_COPY_AND_ASSIGN(QuicTestPacketMaker); | |
238 }; | |
239 | |
240 } // namespace test | |
241 } // namespace net | |
242 | |
243 #endif // NET_QUIC_TEST_TOOLS_QUIC_TEST_PACKET_MAKER_H_ | |
OLD | NEW |