Chromium Code Reviews
chromiumcodereview-hr@appspot.gserviceaccount.com (chromiumcodereview-hr) | Please choose your nickname with Settings | Help | Chromium Project | Gerrit Changes | Sign out
(741)

Side by Side Diff: net/quic/test_tools/quic_test_packet_maker.h

Issue 2565563002: Move various Chromium QUIC files to net/quic/chromium where they belong (Closed)
Patch Set: Created 4 years ago
Use n/p to move between diff chunks; N/P to move between comments. Draft comments are only viewable by you.
Jump to:
View unified diff | Download patch
OLDNEW
(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_
OLDNEW
« no previous file with comments | « net/quic/test_tools/mock_crypto_client_stream_factory.cc ('k') | net/quic/test_tools/quic_test_packet_maker.cc » ('j') | no next file with comments »

Powered by Google App Engine
This is Rietveld 408576698