| 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 |
|---|
Chromium Code Reviews
Issue 2565563002:
Move various Chromium QUIC files to net/quic/chromium where they belong (Closed)
