OLD | NEW |
1 // Copyright 2013 The Chromium Authors. All rights reserved. | 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 | 2 // Use of this source code is governed by a BSD-style license that can be |
3 // found in the LICENSE file. | 3 // found in the LICENSE file. |
4 | 4 |
5 #include "net/quic/test_tools/quic_test_packet_maker.h" | 5 #include "net/quic/test_tools/quic_test_packet_maker.h" |
6 | 6 |
7 #include <list> | 7 #include <list> |
8 | 8 |
9 #include "net/quic/quic_framer.h" | 9 #include "net/quic/quic_framer.h" |
10 #include "net/quic/quic_http_utils.h" | 10 #include "net/quic/quic_http_utils.h" |
11 #include "net/quic/quic_utils.h" | 11 #include "net/quic/quic_utils.h" |
12 #include "net/quic/test_tools/quic_test_utils.h" | 12 #include "net/quic/test_tools/quic_test_utils.h" |
13 | 13 |
14 using std::make_pair; | 14 using std::make_pair; |
15 | 15 |
16 namespace net { | 16 namespace net { |
17 namespace test { | 17 namespace test { |
18 | 18 |
19 QuicTestPacketMaker::QuicTestPacketMaker(QuicVersion version, | 19 QuicTestPacketMaker::QuicTestPacketMaker(QuicVersion version, |
20 QuicConnectionId connection_id, | 20 QuicConnectionId connection_id, |
21 MockClock* clock) | 21 MockClock* clock) |
22 : version_(version), | 22 : version_(version), |
23 connection_id_(connection_id), | 23 connection_id_(connection_id), |
24 clock_(clock), | 24 clock_(clock), |
25 spdy_request_framer_(SPDY3), | 25 spdy_request_framer_(version > QUIC_VERSION_23 ? SPDY4 : SPDY3), |
26 spdy_response_framer_(SPDY3) { | 26 spdy_response_framer_(version > QUIC_VERSION_23 ? SPDY4 : SPDY3) { |
27 } | 27 } |
28 | 28 |
29 QuicTestPacketMaker::~QuicTestPacketMaker() { | 29 QuicTestPacketMaker::~QuicTestPacketMaker() { |
30 } | 30 } |
31 | 31 |
32 scoped_ptr<QuicEncryptedPacket> QuicTestPacketMaker::MakeRstPacket( | 32 scoped_ptr<QuicEncryptedPacket> QuicTestPacketMaker::MakeRstPacket( |
33 QuicPacketSequenceNumber num, | 33 QuicPacketSequenceNumber num, |
34 bool include_version, | 34 bool include_version, |
35 QuicStreamId stream_id, | 35 QuicStreamId stream_id, |
36 QuicRstStreamErrorCode error_code) { | 36 QuicRstStreamErrorCode error_code) { |
(...skipping 137 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
174 return MakePacket(header_, QuicFrame(&frame)); | 174 return MakePacket(header_, QuicFrame(&frame)); |
175 } | 175 } |
176 | 176 |
177 scoped_ptr<QuicEncryptedPacket> QuicTestPacketMaker::MakeRequestHeadersPacket( | 177 scoped_ptr<QuicEncryptedPacket> QuicTestPacketMaker::MakeRequestHeadersPacket( |
178 QuicPacketSequenceNumber sequence_number, | 178 QuicPacketSequenceNumber sequence_number, |
179 QuicStreamId stream_id, | 179 QuicStreamId stream_id, |
180 bool should_include_version, | 180 bool should_include_version, |
181 bool fin, | 181 bool fin, |
182 const SpdyHeaderBlock& headers) { | 182 const SpdyHeaderBlock& headers) { |
183 InitializeHeader(sequence_number, should_include_version); | 183 InitializeHeader(sequence_number, should_include_version); |
184 SpdySynStreamIR syn_stream(stream_id); | 184 scoped_ptr<SpdySerializedFrame> spdy_frame; |
185 syn_stream.set_name_value_block(headers); | 185 if (spdy_request_framer_.protocol_version() == SPDY3) { |
186 syn_stream.set_fin(fin); | 186 SpdySynStreamIR syn_stream(stream_id); |
187 syn_stream.set_priority(0); | 187 syn_stream.set_name_value_block(headers); |
188 scoped_ptr<SpdySerializedFrame> spdy_frame( | 188 syn_stream.set_fin(fin); |
189 spdy_request_framer_.SerializeSynStream(syn_stream)); | 189 syn_stream.set_priority(0); |
| 190 spdy_frame.reset(spdy_request_framer_.SerializeSynStream(syn_stream)); |
| 191 } else { |
| 192 SpdyHeadersIR headers_frame(stream_id); |
| 193 headers_frame.set_name_value_block(headers); |
| 194 headers_frame.set_fin(fin); |
| 195 headers_frame.set_has_priority(true); |
| 196 spdy_frame.reset(spdy_request_framer_.SerializeFrame(headers_frame)); |
| 197 } |
190 QuicStreamFrame frame(kHeadersStreamId, false, 0, | 198 QuicStreamFrame frame(kHeadersStreamId, false, 0, |
191 MakeIOVector(base::StringPiece(spdy_frame->data(), | 199 MakeIOVector(base::StringPiece(spdy_frame->data(), |
192 spdy_frame->size()))); | 200 spdy_frame->size()))); |
193 return MakePacket(header_, QuicFrame(&frame)); | 201 return MakePacket(header_, QuicFrame(&frame)); |
194 } | 202 } |
195 | 203 |
196 scoped_ptr<QuicEncryptedPacket> QuicTestPacketMaker::MakeResponseHeadersPacket( | 204 scoped_ptr<QuicEncryptedPacket> QuicTestPacketMaker::MakeResponseHeadersPacket( |
197 QuicPacketSequenceNumber sequence_number, | 205 QuicPacketSequenceNumber sequence_number, |
198 QuicStreamId stream_id, | 206 QuicStreamId stream_id, |
199 bool should_include_version, | 207 bool should_include_version, |
200 bool fin, | 208 bool fin, |
201 const SpdyHeaderBlock& headers) { | 209 const SpdyHeaderBlock& headers) { |
202 InitializeHeader(sequence_number, should_include_version); | 210 InitializeHeader(sequence_number, should_include_version); |
203 SpdySynReplyIR syn_reply(stream_id); | 211 scoped_ptr<SpdySerializedFrame> spdy_frame; |
204 syn_reply.set_name_value_block(headers); | 212 if (spdy_request_framer_.protocol_version() == SPDY3) { |
205 syn_reply.set_fin(fin); | 213 SpdySynReplyIR syn_reply(stream_id); |
206 scoped_ptr<SpdySerializedFrame> spdy_frame( | 214 syn_reply.set_name_value_block(headers); |
207 spdy_response_framer_.SerializeSynReply(syn_reply)); | 215 syn_reply.set_fin(fin); |
| 216 spdy_frame.reset(spdy_response_framer_.SerializeSynReply(syn_reply)); |
| 217 } else { |
| 218 SpdyHeadersIR headers_frame(stream_id); |
| 219 headers_frame.set_name_value_block(headers); |
| 220 headers_frame.set_fin(fin); |
| 221 spdy_frame.reset(spdy_request_framer_.SerializeFrame(headers_frame)); |
| 222 } |
208 QuicStreamFrame frame(kHeadersStreamId, false, 0, | 223 QuicStreamFrame frame(kHeadersStreamId, false, 0, |
209 MakeIOVector(base::StringPiece(spdy_frame->data(), | 224 MakeIOVector(base::StringPiece(spdy_frame->data(), |
210 spdy_frame->size()))); | 225 spdy_frame->size()))); |
211 return MakePacket(header_, QuicFrame(&frame)); | 226 return MakePacket(header_, QuicFrame(&frame)); |
212 } | 227 } |
213 | 228 |
214 SpdyHeaderBlock QuicTestPacketMaker::GetRequestHeaders( | 229 SpdyHeaderBlock QuicTestPacketMaker::GetRequestHeaders( |
215 const std::string& method, | 230 const std::string& method, |
216 const std::string& scheme, | 231 const std::string& scheme, |
217 const std::string& path) { | 232 const std::string& path) { |
(...skipping 35 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
253 header_.public_header.version_flag = should_include_version; | 268 header_.public_header.version_flag = should_include_version; |
254 header_.public_header.sequence_number_length = PACKET_1BYTE_SEQUENCE_NUMBER; | 269 header_.public_header.sequence_number_length = PACKET_1BYTE_SEQUENCE_NUMBER; |
255 header_.packet_sequence_number = sequence_number; | 270 header_.packet_sequence_number = sequence_number; |
256 header_.fec_group = 0; | 271 header_.fec_group = 0; |
257 header_.entropy_flag = false; | 272 header_.entropy_flag = false; |
258 header_.fec_flag = false; | 273 header_.fec_flag = false; |
259 } | 274 } |
260 | 275 |
261 } // namespace test | 276 } // namespace test |
262 } // namespace net | 277 } // namespace net |
OLD | NEW |