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

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

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
« no previous file with comments | « net/quic/test_tools/quic_test_packet_maker.h ('k') | no next file » | no next file with comments »
Toggle Intra-line Diffs ('i') | Expand Comments ('e') | Collapse Comments ('c') | Show Comments Hide Comments ('s')
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 #include "net/quic/test_tools/quic_test_packet_maker.h"
6
7 #include <list>
8 #include <utility>
9
10 #include "base/memory/ptr_util.h"
11 #include "net/quic/core/quic_framer.h"
12 #include "net/quic/core/quic_http_utils.h"
13 #include "net/quic/core/quic_utils.h"
14 #include "net/quic/test_tools/quic_test_utils.h"
15
16
17 namespace net {
18 namespace test {
19
20 QuicTestPacketMaker::QuicTestPacketMaker(QuicVersion version,
21 QuicConnectionId connection_id,
22 MockClock* clock,
23 const std::string& host,
24 Perspective perspective)
25 : version_(version),
26 connection_id_(connection_id),
27 clock_(clock),
28 host_(host),
29 perspective_(perspective) {}
30
31 QuicTestPacketMaker::~QuicTestPacketMaker() {}
32
33 void QuicTestPacketMaker::set_hostname(const std::string& host) {
34 host_.assign(host);
35 }
36
37 std::unique_ptr<QuicReceivedPacket> QuicTestPacketMaker::MakePingPacket(
38 QuicPacketNumber num,
39 bool include_version) {
40 QuicPacketHeader header;
41 header.public_header.connection_id = connection_id_;
42 header.public_header.reset_flag = false;
43 header.public_header.version_flag = include_version;
44 header.public_header.packet_number_length = PACKET_1BYTE_PACKET_NUMBER;
45 header.packet_number = num;
46
47 QuicPingFrame ping;
48 return std::unique_ptr<QuicReceivedPacket>(
49 MakePacket(header, QuicFrame(ping)));
50 }
51
52 std::unique_ptr<QuicReceivedPacket> QuicTestPacketMaker::MakeRstPacket(
53 QuicPacketNumber num,
54 bool include_version,
55 QuicStreamId stream_id,
56 QuicRstStreamErrorCode error_code) {
57 return MakeRstPacket(num, include_version, stream_id, error_code, 0);
58 }
59
60 std::unique_ptr<QuicReceivedPacket> QuicTestPacketMaker::MakeRstPacket(
61 QuicPacketNumber num,
62 bool include_version,
63 QuicStreamId stream_id,
64 QuicRstStreamErrorCode error_code,
65 size_t bytes_written) {
66 QuicPacketHeader header;
67 header.public_header.connection_id = connection_id_;
68 header.public_header.reset_flag = false;
69 header.public_header.version_flag = include_version;
70 header.public_header.packet_number_length = PACKET_1BYTE_PACKET_NUMBER;
71 header.packet_number = num;
72
73 QuicRstStreamFrame rst(stream_id, error_code, bytes_written);
74 DVLOG(1) << "Adding frame: " << QuicFrame(&rst);
75 return std::unique_ptr<QuicReceivedPacket>(
76 MakePacket(header, QuicFrame(&rst)));
77 }
78
79 std::unique_ptr<QuicReceivedPacket> QuicTestPacketMaker::MakeAckAndRstPacket(
80 QuicPacketNumber num,
81 bool include_version,
82 QuicStreamId stream_id,
83 QuicRstStreamErrorCode error_code,
84 QuicPacketNumber largest_received,
85 QuicPacketNumber ack_least_unacked,
86 QuicPacketNumber stop_least_unacked,
87 bool send_feedback) {
88 QuicPacketHeader header;
89 header.public_header.connection_id = connection_id_;
90 header.public_header.reset_flag = false;
91 header.public_header.version_flag = include_version;
92 header.public_header.packet_number_length = PACKET_1BYTE_PACKET_NUMBER;
93 header.packet_number = num;
94
95 QuicAckFrame ack(MakeAckFrame(largest_received));
96 ack.ack_delay_time = QuicTime::Delta::Zero();
97 for (QuicPacketNumber i = ack_least_unacked; i <= largest_received; ++i) {
98 ack.received_packet_times.push_back(std::make_pair(i, clock_->Now()));
99 }
100 if (largest_received > 0) {
101 ack.packets.Add(1, largest_received + 1);
102 }
103 QuicFrames frames;
104 frames.push_back(QuicFrame(&ack));
105 DVLOG(1) << "Adding frame: " << frames[0];
106
107 QuicStopWaitingFrame stop_waiting;
108 stop_waiting.least_unacked = stop_least_unacked;
109 frames.push_back(QuicFrame(&stop_waiting));
110 DVLOG(1) << "Adding frame: " << frames[1];
111
112 QuicRstStreamFrame rst(stream_id, error_code, 0);
113 frames.push_back(QuicFrame(&rst));
114 DVLOG(1) << "Adding frame: " << frames[2];
115
116 QuicFramer framer(SupportedVersions(version_), clock_->Now(), perspective_);
117 std::unique_ptr<QuicPacket> packet(
118 BuildUnsizedDataPacket(&framer, header, frames));
119 char buffer[kMaxPacketSize];
120 size_t encrypted_size = framer.EncryptPayload(ENCRYPTION_NONE, /*path_id=*/0u,
121 header.packet_number, *packet,
122 buffer, kMaxPacketSize);
123 EXPECT_NE(0u, encrypted_size);
124 QuicReceivedPacket encrypted(buffer, encrypted_size, QuicTime::Zero(), false);
125 return std::unique_ptr<QuicReceivedPacket>(encrypted.Clone());
126 }
127
128 std::unique_ptr<QuicReceivedPacket>
129 QuicTestPacketMaker::MakeAckAndConnectionClosePacket(
130 QuicPacketNumber num,
131 bool include_version,
132 QuicTime::Delta ack_delay_time,
133 QuicPacketNumber largest_received,
134 QuicPacketNumber least_unacked,
135 QuicErrorCode quic_error,
136 const std::string& quic_error_details) {
137 QuicPacketHeader header;
138 header.public_header.connection_id = connection_id_;
139 header.public_header.reset_flag = false;
140 header.public_header.version_flag = include_version;
141 header.public_header.packet_number_length = PACKET_1BYTE_PACKET_NUMBER;
142 header.packet_number = num;
143
144 QuicAckFrame ack(MakeAckFrame(largest_received));
145 ack.ack_delay_time = ack_delay_time;
146 for (QuicPacketNumber i = least_unacked; i <= largest_received; ++i) {
147 ack.received_packet_times.push_back(std::make_pair(i, clock_->Now()));
148 }
149 if (largest_received > 0) {
150 ack.packets.Add(1, largest_received + 1);
151 }
152 QuicFrames frames;
153 frames.push_back(QuicFrame(&ack));
154 DVLOG(1) << "Adding frame: " << frames[0];
155
156 QuicStopWaitingFrame stop_waiting;
157 stop_waiting.least_unacked = least_unacked;
158 frames.push_back(QuicFrame(&stop_waiting));
159 DVLOG(1) << "Adding frame: " << frames[1];
160
161 QuicConnectionCloseFrame close;
162 close.error_code = quic_error;
163 close.error_details = quic_error_details;
164
165 frames.push_back(QuicFrame(&close));
166 DVLOG(1) << "Adding frame: " << frames[2];
167
168 QuicFramer framer(SupportedVersions(version_), clock_->Now(), perspective_);
169 std::unique_ptr<QuicPacket> packet(
170 BuildUnsizedDataPacket(&framer, header, frames));
171 char buffer[kMaxPacketSize];
172 size_t encrypted_size = framer.EncryptPayload(ENCRYPTION_NONE, /*path_id=*/0u,
173 header.packet_number, *packet,
174 buffer, kMaxPacketSize);
175 EXPECT_NE(0u, encrypted_size);
176 QuicReceivedPacket encrypted(buffer, encrypted_size, clock_->Now(), false);
177 return std::unique_ptr<QuicReceivedPacket>(encrypted.Clone());
178 }
179
180 std::unique_ptr<QuicReceivedPacket>
181 QuicTestPacketMaker::MakeConnectionClosePacket(QuicPacketNumber num) {
182 QuicPacketHeader header;
183 header.public_header.connection_id = connection_id_;
184 header.public_header.reset_flag = false;
185 header.public_header.version_flag = false;
186 header.public_header.packet_number_length = PACKET_1BYTE_PACKET_NUMBER;
187 header.packet_number = num;
188
189 QuicConnectionCloseFrame close;
190 close.error_code = QUIC_CRYPTO_VERSION_NOT_SUPPORTED;
191 close.error_details = "Time to panic!";
192 return std::unique_ptr<QuicReceivedPacket>(
193 MakePacket(header, QuicFrame(&close)));
194 }
195
196 std::unique_ptr<QuicReceivedPacket> QuicTestPacketMaker::MakeGoAwayPacket(
197 QuicPacketNumber num,
198 QuicErrorCode error_code,
199 std::string reason_phrase) {
200 QuicPacketHeader header;
201 header.public_header.connection_id = connection_id_;
202 header.public_header.reset_flag = false;
203 header.public_header.version_flag = false;
204 header.public_header.packet_number_length = PACKET_1BYTE_PACKET_NUMBER;
205 header.packet_number = num;
206
207 QuicGoAwayFrame goaway;
208 goaway.error_code = error_code;
209 goaway.last_good_stream_id = 0;
210 goaway.reason_phrase = reason_phrase;
211 return std::unique_ptr<QuicReceivedPacket>(
212 MakePacket(header, QuicFrame(&goaway)));
213 }
214
215 // Sets both least_unacked fields in stop waiting frame and ack frame
216 // to be |least_unacked|.
217 std::unique_ptr<QuicReceivedPacket> QuicTestPacketMaker::MakeAckPacket(
218 QuicPacketNumber packet_number,
219 QuicPacketNumber largest_received,
220 QuicPacketNumber least_unacked,
221 bool send_feedback) {
222 return MakeAckPacket(packet_number, largest_received, least_unacked,
223 least_unacked, send_feedback);
224 }
225
226 std::unique_ptr<QuicReceivedPacket> QuicTestPacketMaker::MakeAckPacket(
227 QuicPacketNumber packet_number,
228 QuicPacketNumber largest_received,
229 QuicPacketNumber ack_least_unacked,
230 QuicPacketNumber stop_least_unacked,
231 bool send_feedback) {
232 QuicPacketHeader header;
233 header.public_header.connection_id = connection_id_;
234 header.public_header.reset_flag = false;
235 header.public_header.version_flag = false;
236 header.public_header.packet_number_length = PACKET_1BYTE_PACKET_NUMBER;
237 header.packet_number = packet_number;
238
239 QuicAckFrame ack(MakeAckFrame(largest_received));
240 ack.ack_delay_time = QuicTime::Delta::Zero();
241 for (QuicPacketNumber i = ack_least_unacked; i <= largest_received; ++i) {
242 ack.received_packet_times.push_back(std::make_pair(i, clock_->Now()));
243 }
244 if (largest_received > 0) {
245 ack.packets.Add(1, largest_received + 1);
246 }
247
248 QuicFramer framer(SupportedVersions(version_), clock_->Now(), perspective_);
249 QuicFrames frames;
250 QuicFrame ack_frame(&ack);
251 DVLOG(1) << "Adding frame: " << ack_frame;
252 frames.push_back(ack_frame);
253
254 QuicStopWaitingFrame stop_waiting;
255 stop_waiting.least_unacked = stop_least_unacked;
256 frames.push_back(QuicFrame(&stop_waiting));
257
258 std::unique_ptr<QuicPacket> packet(
259 BuildUnsizedDataPacket(&framer, header, frames));
260 char buffer[kMaxPacketSize];
261 size_t encrypted_size = framer.EncryptPayload(ENCRYPTION_NONE, /*path_id=*/0u,
262 header.packet_number, *packet,
263 buffer, kMaxPacketSize);
264 EXPECT_NE(0u, encrypted_size);
265 QuicReceivedPacket encrypted(buffer, encrypted_size, clock_->Now(), false);
266 return std::unique_ptr<QuicReceivedPacket>(encrypted.Clone());
267 }
268
269 // Returns a newly created packet to send kData on stream 1.
270 std::unique_ptr<QuicReceivedPacket> QuicTestPacketMaker::MakeDataPacket(
271 QuicPacketNumber packet_number,
272 QuicStreamId stream_id,
273 bool should_include_version,
274 bool fin,
275 QuicStreamOffset offset,
276 base::StringPiece data) {
277 InitializeHeader(packet_number, should_include_version);
278 QuicStreamFrame frame(stream_id, fin, offset, data);
279 DVLOG(1) << "Adding frame: " << frame;
280 return MakePacket(header_, QuicFrame(&frame));
281 }
282
283 std::unique_ptr<QuicReceivedPacket>
284 QuicTestPacketMaker::MakeMultipleDataFramesPacket(
285 QuicPacketNumber packet_number,
286 QuicStreamId stream_id,
287 bool should_include_version,
288 bool fin,
289 QuicStreamOffset offset,
290 const std::vector<std::string>& data_writes) {
291 InitializeHeader(packet_number, should_include_version);
292 QuicFrames data_frames;
293 // QuicFrame takes a raw pointer. Use a std::vector here so we keep
294 // StreamFrames alive until MakeMultipleFramesPacket is done.
295 std::vector<std::unique_ptr<QuicStreamFrame>> stream_frames;
296 for (size_t i = 0; i < data_writes.size(); ++i) {
297 bool is_fin = fin && (i == data_writes.size() - 1);
298 stream_frames.push_back(base::MakeUnique<QuicStreamFrame>(
299 stream_id, is_fin, offset, base::StringPiece(data_writes[i])));
300 offset += data_writes[i].length();
301 }
302 for (const auto& stream_frame : stream_frames) {
303 QuicFrame quic_frame(stream_frame.get());
304 DVLOG(1) << "Adding frame: " << quic_frame;
305 data_frames.push_back(quic_frame);
306 }
307 return MakeMultipleFramesPacket(header_, data_frames);
308 }
309
310 std::unique_ptr<QuicReceivedPacket> QuicTestPacketMaker::MakeAckAndDataPacket(
311 QuicPacketNumber packet_number,
312 bool include_version,
313 QuicStreamId stream_id,
314 QuicPacketNumber largest_received,
315 QuicPacketNumber least_unacked,
316 bool fin,
317 QuicStreamOffset offset,
318 base::StringPiece data) {
319 InitializeHeader(packet_number, include_version);
320
321 QuicAckFrame ack(MakeAckFrame(largest_received));
322 ack.ack_delay_time = QuicTime::Delta::Zero();
323 for (QuicPacketNumber i = least_unacked; i <= largest_received; ++i) {
324 ack.received_packet_times.push_back(std::make_pair(i, clock_->Now()));
325 }
326 if (largest_received > 0) {
327 ack.packets.Add(1, largest_received + 1);
328 }
329 QuicFrames frames;
330 frames.push_back(QuicFrame(&ack));
331
332 QuicStopWaitingFrame stop_waiting;
333 stop_waiting.least_unacked = least_unacked;
334 frames.push_back(QuicFrame(&stop_waiting));
335
336 QuicStreamFrame stream_frame(stream_id, fin, offset, data);
337 frames.push_back(QuicFrame(&stream_frame));
338
339 return MakeMultipleFramesPacket(header_, frames);
340 }
341
342 std::unique_ptr<QuicReceivedPacket>
343 QuicTestPacketMaker::MakeRequestHeadersAndMultipleDataFramesPacket(
344 QuicPacketNumber packet_number,
345 QuicStreamId stream_id,
346 bool should_include_version,
347 bool fin,
348 SpdyPriority priority,
349 SpdyHeaderBlock headers,
350 QuicStreamOffset* header_stream_offset,
351 size_t* spdy_headers_frame_length,
352 const std::vector<std::string>& data_writes) {
353 InitializeHeader(packet_number, should_include_version);
354 SpdySerializedFrame spdy_frame;
355 SpdyHeadersIR headers_frame(stream_id, std::move(headers));
356 headers_frame.set_fin(fin);
357 headers_frame.set_weight(Spdy3PriorityToHttp2Weight(priority));
358 headers_frame.set_has_priority(true);
359 spdy_frame = spdy_request_framer_.SerializeFrame(headers_frame);
360
361 if (spdy_headers_frame_length) {
362 *spdy_headers_frame_length = spdy_frame.size();
363 }
364 QuicFrames frames;
365 QuicStreamOffset header_offset =
366 header_stream_offset == nullptr ? 0 : *header_stream_offset;
367 QuicStreamFrame frame(
368 kHeadersStreamId, false, header_offset,
369 base::StringPiece(spdy_frame.data(), spdy_frame.size()));
370 frames.push_back(QuicFrame(&frame));
371 if (header_stream_offset != nullptr) {
372 *header_stream_offset += spdy_frame.size();
373 }
374
375 QuicStreamOffset offset = 0;
376 // QuicFrame takes a raw pointer. Use a std::vector here so we keep
377 // StreamFrames alive until MakeMultipleFramesPacket is done.
378 std::vector<std::unique_ptr<QuicStreamFrame>> stream_frames;
379 for (size_t i = 0; i < data_writes.size(); ++i) {
380 bool is_fin = fin && (i == data_writes.size() - 1);
381 stream_frames.push_back(base::MakeUnique<QuicStreamFrame>(
382 stream_id, is_fin, offset, base::StringPiece(data_writes[i])));
383 offset += data_writes[i].length();
384 }
385 for (const auto& stream_frame : stream_frames) {
386 QuicFrame quic_frame(stream_frame.get());
387 DVLOG(1) << "Adding frame: " << quic_frame;
388 frames.push_back(quic_frame);
389 }
390 return MakeMultipleFramesPacket(header_, frames);
391 }
392
393 std::unique_ptr<QuicReceivedPacket>
394 QuicTestPacketMaker::MakeRequestHeadersPacket(
395 QuicPacketNumber packet_number,
396 QuicStreamId stream_id,
397 bool should_include_version,
398 bool fin,
399 SpdyPriority priority,
400 SpdyHeaderBlock headers,
401 size_t* spdy_headers_frame_length) {
402 return MakeRequestHeadersPacket(
403 packet_number, stream_id, should_include_version, fin, priority,
404 std::move(headers), spdy_headers_frame_length, nullptr);
405 }
406
407 // If |offset| is provided, will use the value when creating the packet.
408 // Will also update the value after packet creation.
409 std::unique_ptr<QuicReceivedPacket>
410 QuicTestPacketMaker::MakeRequestHeadersPacket(QuicPacketNumber packet_number,
411 QuicStreamId stream_id,
412 bool should_include_version,
413 bool fin,
414 SpdyPriority priority,
415 SpdyHeaderBlock headers,
416 size_t* spdy_headers_frame_length,
417 QuicStreamOffset* offset) {
418 InitializeHeader(packet_number, should_include_version);
419 SpdySerializedFrame spdy_frame;
420 SpdyHeadersIR headers_frame(stream_id, std::move(headers));
421 headers_frame.set_fin(fin);
422 headers_frame.set_weight(Spdy3PriorityToHttp2Weight(priority));
423 headers_frame.set_has_priority(true);
424 spdy_frame = spdy_request_framer_.SerializeFrame(headers_frame);
425
426 if (spdy_headers_frame_length) {
427 *spdy_headers_frame_length = spdy_frame.size();
428 }
429 if (offset != nullptr) {
430 QuicStreamFrame frame(
431 kHeadersStreamId, false, *offset,
432 base::StringPiece(spdy_frame.data(), spdy_frame.size()));
433 *offset += spdy_frame.size();
434 return MakePacket(header_, QuicFrame(&frame));
435 } else {
436 QuicStreamFrame frame(
437 kHeadersStreamId, false, 0,
438 base::StringPiece(spdy_frame.data(), spdy_frame.size()));
439
440 return MakePacket(header_, QuicFrame(&frame));
441 }
442 }
443
444 // Convenience method for calling MakeRequestHeadersPacket with nullptr for
445 // |spdy_headers_frame_length|.
446 std::unique_ptr<QuicReceivedPacket>
447 QuicTestPacketMaker::MakeRequestHeadersPacketWithOffsetTracking(
448 QuicPacketNumber packet_number,
449 QuicStreamId stream_id,
450 bool should_include_version,
451 bool fin,
452 SpdyPriority priority,
453 SpdyHeaderBlock headers,
454 QuicStreamOffset* offset) {
455 return MakeRequestHeadersPacket(packet_number, stream_id,
456 should_include_version, fin, priority,
457 std::move(headers), nullptr, offset);
458 }
459
460 // If |offset| is provided, will use the value when creating the packet.
461 // Will also update the value after packet creation.
462 std::unique_ptr<QuicReceivedPacket> QuicTestPacketMaker::MakePushPromisePacket(
463 QuicPacketNumber packet_number,
464 QuicStreamId stream_id,
465 QuicStreamId promised_stream_id,
466 bool should_include_version,
467 bool fin,
468 SpdyHeaderBlock headers,
469 size_t* spdy_headers_frame_length,
470 QuicStreamOffset* offset) {
471 InitializeHeader(packet_number, should_include_version);
472 SpdySerializedFrame spdy_frame;
473 SpdyPushPromiseIR promise_frame(stream_id, promised_stream_id,
474 std::move(headers));
475 promise_frame.set_fin(fin);
476 spdy_frame = spdy_request_framer_.SerializeFrame(promise_frame);
477 if (spdy_headers_frame_length) {
478 *spdy_headers_frame_length = spdy_frame.size();
479 }
480 if (offset != nullptr) {
481 QuicStreamFrame frame(
482 kHeadersStreamId, false, *offset,
483 base::StringPiece(spdy_frame.data(), spdy_frame.size()));
484 *offset += spdy_frame.size();
485 return MakePacket(header_, QuicFrame(&frame));
486 } else {
487 QuicStreamFrame frame(
488 kHeadersStreamId, false, 0,
489 base::StringPiece(spdy_frame.data(), spdy_frame.size()));
490 return MakePacket(header_, QuicFrame(&frame));
491 }
492 }
493
494 std::unique_ptr<QuicReceivedPacket> QuicTestPacketMaker::MakeForceHolDataPacket(
495 QuicPacketNumber packet_number,
496 QuicStreamId stream_id,
497 bool should_include_version,
498 bool fin,
499 QuicStreamOffset* offset,
500 base::StringPiece data) {
501 SpdyDataIR spdy_data(stream_id, data);
502 spdy_data.set_fin(fin);
503 SpdySerializedFrame spdy_frame(
504 spdy_request_framer_.SerializeFrame(spdy_data));
505 InitializeHeader(packet_number, should_include_version);
506 QuicStreamFrame quic_frame(kHeadersStreamId, false, *offset,
507 StringPiece(spdy_frame.data(), spdy_frame.size()));
508 *offset += spdy_frame.size();
509 return MakePacket(header_, QuicFrame(&quic_frame));
510 }
511
512 // If |offset| is provided, will use the value when creating the packet.
513 // Will also update the value after packet creation.
514 std::unique_ptr<QuicReceivedPacket>
515 QuicTestPacketMaker::MakeResponseHeadersPacket(
516 QuicPacketNumber packet_number,
517 QuicStreamId stream_id,
518 bool should_include_version,
519 bool fin,
520 SpdyHeaderBlock headers,
521 size_t* spdy_headers_frame_length,
522 QuicStreamOffset* offset) {
523 InitializeHeader(packet_number, should_include_version);
524 SpdySerializedFrame spdy_frame;
525 SpdyHeadersIR headers_frame(stream_id, std::move(headers));
526 headers_frame.set_fin(fin);
527 spdy_frame = spdy_response_framer_.SerializeFrame(headers_frame);
528
529 if (spdy_headers_frame_length) {
530 *spdy_headers_frame_length = spdy_frame.size();
531 }
532 if (offset != nullptr) {
533 QuicStreamFrame frame(
534 kHeadersStreamId, false, *offset,
535 base::StringPiece(spdy_frame.data(), spdy_frame.size()));
536 *offset += spdy_frame.size();
537 return MakePacket(header_, QuicFrame(&frame));
538 } else {
539 QuicStreamFrame frame(
540 kHeadersStreamId, false, 0,
541 base::StringPiece(spdy_frame.data(), spdy_frame.size()));
542 return MakePacket(header_, QuicFrame(&frame));
543 }
544 }
545
546 std::unique_ptr<QuicReceivedPacket>
547 QuicTestPacketMaker::MakeResponseHeadersPacket(
548 QuicPacketNumber packet_number,
549 QuicStreamId stream_id,
550 bool should_include_version,
551 bool fin,
552 SpdyHeaderBlock headers,
553 size_t* spdy_headers_frame_length) {
554 return MakeResponseHeadersPacket(
555 packet_number, stream_id, should_include_version, fin, std::move(headers),
556 spdy_headers_frame_length, nullptr);
557 }
558
559 // Convenience method for calling MakeResponseHeadersPacket with nullptr for
560 // |spdy_headers_frame_length|.
561 std::unique_ptr<QuicReceivedPacket>
562 QuicTestPacketMaker::MakeResponseHeadersPacketWithOffsetTracking(
563 QuicPacketNumber packet_number,
564 QuicStreamId stream_id,
565 bool should_include_version,
566 bool fin,
567 SpdyHeaderBlock headers,
568 QuicStreamOffset* offset) {
569 return MakeResponseHeadersPacket(packet_number, stream_id,
570 should_include_version, fin,
571 std::move(headers), nullptr, offset);
572 }
573
574 SpdyHeaderBlock QuicTestPacketMaker::GetRequestHeaders(
575 const std::string& method,
576 const std::string& scheme,
577 const std::string& path) {
578 SpdyHeaderBlock headers;
579 headers[":method"] = method;
580 headers[":authority"] = host_;
581 headers[":scheme"] = scheme;
582 headers[":path"] = path;
583 return headers;
584 }
585
586 SpdyHeaderBlock QuicTestPacketMaker::GetResponseHeaders(
587 const std::string& status) {
588 SpdyHeaderBlock headers;
589 headers[":status"] = status;
590 headers["content-type"] = "text/plain";
591 return headers;
592 }
593
594 SpdyHeaderBlock QuicTestPacketMaker::GetResponseHeaders(
595 const std::string& status,
596 const std::string& alt_svc) {
597 SpdyHeaderBlock headers;
598 headers[":status"] = status;
599 headers["alt-svc"] = alt_svc;
600 headers["content-type"] = "text/plain";
601 return headers;
602 }
603
604 std::unique_ptr<QuicReceivedPacket> QuicTestPacketMaker::MakePacket(
605 const QuicPacketHeader& header,
606 const QuicFrame& frame) {
607 QuicFrames frames;
608 frames.push_back(frame);
609 return MakeMultipleFramesPacket(header, frames);
610 }
611
612 std::unique_ptr<QuicReceivedPacket>
613 QuicTestPacketMaker::MakeMultipleFramesPacket(const QuicPacketHeader& header,
614 const QuicFrames& frames) {
615 QuicFramer framer(SupportedVersions(version_), clock_->Now(), perspective_);
616 std::unique_ptr<QuicPacket> packet(
617 BuildUnsizedDataPacket(&framer, header, frames));
618 char buffer[kMaxPacketSize];
619 size_t encrypted_size = framer.EncryptPayload(ENCRYPTION_NONE, /*path_id=*/0u,
620 header.packet_number, *packet,
621 buffer, kMaxPacketSize);
622 EXPECT_NE(0u, encrypted_size);
623 QuicReceivedPacket encrypted(buffer, encrypted_size, clock_->Now(), false);
624 return std::unique_ptr<QuicReceivedPacket>(encrypted.Clone());
625 }
626
627 void QuicTestPacketMaker::InitializeHeader(QuicPacketNumber packet_number,
628 bool should_include_version) {
629 header_.public_header.connection_id = connection_id_;
630 header_.public_header.reset_flag = false;
631 header_.public_header.version_flag = should_include_version;
632 header_.public_header.packet_number_length = PACKET_1BYTE_PACKET_NUMBER;
633 header_.packet_number = packet_number;
634 }
635
636 std::unique_ptr<QuicReceivedPacket> QuicTestPacketMaker::MakeSettingsPacket(
637 QuicPacketNumber packet_number,
638 SpdySettingsIds id,
639 size_t value,
640 bool should_include_version,
641 QuicStreamOffset* offset) {
642 SpdySettingsIR settings_frame;
643 settings_frame.AddSetting(id, false, false, value);
644 SpdySerializedFrame spdy_frame(
645 spdy_request_framer_.SerializeFrame(settings_frame));
646 InitializeHeader(packet_number, should_include_version);
647 if (offset != nullptr) {
648 QuicStreamFrame quic_frame(
649 kHeadersStreamId, false, *offset,
650 StringPiece(spdy_frame.data(), spdy_frame.size()));
651 *offset += spdy_frame.size();
652 return MakePacket(header_, QuicFrame(&quic_frame));
653 } else {
654 QuicStreamFrame quic_frame(
655 kHeadersStreamId, false, 0,
656 StringPiece(spdy_frame.data(), spdy_frame.size()));
657 LOG(INFO) << "quic_frame: " << quic_frame;
658 return MakePacket(header_, QuicFrame(&quic_frame));
659 }
660 }
661
662 } // namespace test
663 } // namespace net
OLDNEW
« no previous file with comments | « net/quic/test_tools/quic_test_packet_maker.h ('k') | no next file » | no next file with comments »

Powered by Google App Engine
This is Rietveld 408576698