• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
1 // Copyright (c) 2011 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 #ifndef NET_SPDY_SPDY_TEST_UTIL_H_
6 #define NET_SPDY_SPDY_TEST_UTIL_H_
7 #pragma once
8 
9 #include "base/basictypes.h"
10 #include "net/base/cert_verifier.h"
11 #include "net/base/mock_host_resolver.h"
12 #include "net/base/request_priority.h"
13 #include "net/base/ssl_config_service_defaults.h"
14 #include "net/http/http_auth_handler_factory.h"
15 #include "net/http/http_cache.h"
16 #include "net/http/http_network_session.h"
17 #include "net/http/http_network_layer.h"
18 #include "net/http/http_transaction_factory.h"
19 #include "net/proxy/proxy_service.h"
20 #include "net/socket/socket_test_util.h"
21 #include "net/spdy/spdy_framer.h"
22 #include "net/url_request/url_request_context.h"
23 
24 namespace net {
25 
26 // Default upload data used by both, mock objects and framer when creating
27 // data frames.
28 const char kDefaultURL[] = "http://www.google.com";
29 const char kUploadData[] = "hello!";
30 const int kUploadDataSize = arraysize(kUploadData)-1;
31 
32 // NOTE: In GCC, on a Mac, this can't be in an anonymous namespace!
33 // This struct holds information used to construct spdy control and data frames.
34 struct SpdyHeaderInfo {
35   spdy::SpdyControlType kind;
36   spdy::SpdyStreamId id;
37   spdy::SpdyStreamId assoc_id;
38   spdy::SpdyPriority priority;
39   spdy::SpdyControlFlags control_flags;
40   bool compressed;
41   spdy::SpdyStatusCodes status;
42   const char* data;
43   uint32 data_length;
44   spdy::SpdyDataFlags data_flags;
45 };
46 
47 // Chop a frame into an array of MockWrites.
48 // |data| is the frame to chop.
49 // |length| is the length of the frame to chop.
50 // |num_chunks| is the number of chunks to create.
51 MockWrite* ChopWriteFrame(const char* data, int length, int num_chunks);
52 
53 // Chop a SpdyFrame into an array of MockWrites.
54 // |frame| is the frame to chop.
55 // |num_chunks| is the number of chunks to create.
56 MockWrite* ChopWriteFrame(const spdy::SpdyFrame& frame, int num_chunks);
57 
58 // Chop a frame into an array of MockReads.
59 // |data| is the frame to chop.
60 // |length| is the length of the frame to chop.
61 // |num_chunks| is the number of chunks to create.
62 MockRead* ChopReadFrame(const char* data, int length, int num_chunks);
63 
64 // Chop a SpdyFrame into an array of MockReads.
65 // |frame| is the frame to chop.
66 // |num_chunks| is the number of chunks to create.
67 MockRead* ChopReadFrame(const spdy::SpdyFrame& frame, int num_chunks);
68 
69 // Adds headers and values to a map.
70 // |extra_headers| is an array of { name, value } pairs, arranged as strings
71 // where the even entries are the header names, and the odd entries are the
72 // header values.
73 // |headers| gets filled in from |extra_headers|.
74 void AppendHeadersToSpdyFrame(const char* const extra_headers[],
75                               int extra_header_count,
76                               spdy::SpdyHeaderBlock* headers);
77 
78 // Writes |str| of the given |len| to the buffer pointed to by |buffer_handle|.
79 // Uses a template so buffer_handle can be a char* or an unsigned char*.
80 // Updates the |*buffer_handle| pointer by |len|
81 // Returns the number of bytes written into *|buffer_handle|
82 template<class T>
AppendToBuffer(const char * str,int len,T ** buffer_handle,int * buffer_len_remaining)83 int AppendToBuffer(const char* str,
84                    int len,
85                    T** buffer_handle,
86                    int* buffer_len_remaining) {
87   DCHECK_GT(len, 0);
88   DCHECK(NULL != buffer_handle) << "NULL buffer handle";
89   DCHECK(NULL != *buffer_handle) << "NULL pointer";
90   DCHECK(NULL != buffer_len_remaining)
91       << "NULL buffer remainder length pointer";
92   DCHECK_GE(*buffer_len_remaining, len) << "Insufficient buffer size";
93   memcpy(*buffer_handle, str, len);
94   *buffer_handle += len;
95   *buffer_len_remaining -= len;
96   return len;
97 }
98 
99 // Writes |val| to a location of size |len|, in big-endian format.
100 // in the buffer pointed to by |buffer_handle|.
101 // Updates the |*buffer_handle| pointer by |len|
102 // Returns the number of bytes written
103 int AppendToBuffer(int val,
104                    int len,
105                    unsigned char** buffer_handle,
106                    int* buffer_len_remaining);
107 
108 // Construct a SPDY packet.
109 // |head| is the start of the packet, up to but not including
110 // the header value pairs.
111 // |extra_headers| are the extra header-value pairs, which typically
112 // will vary the most between calls.
113 // |tail| is any (relatively constant) header-value pairs to add.
114 // |buffer| is the buffer we're filling in.
115 // Returns a SpdyFrame.
116 spdy::SpdyFrame* ConstructSpdyPacket(const SpdyHeaderInfo& header_info,
117                                      const char* const extra_headers[],
118                                      int extra_header_count,
119                                      const char* const tail[],
120                                      int tail_header_count);
121 
122 // Construct a generic SpdyControlFrame.
123 spdy::SpdyFrame* ConstructSpdyControlFrame(const char* const extra_headers[],
124                                            int extra_header_count,
125                                            bool compressed,
126                                            int stream_id,
127                                            RequestPriority request_priority,
128                                            spdy::SpdyControlType type,
129                                            spdy::SpdyControlFlags flags,
130                                            const char* const* kHeaders,
131                                            int kHeadersSize);
132 spdy::SpdyFrame* ConstructSpdyControlFrame(const char* const extra_headers[],
133                                            int extra_header_count,
134                                            bool compressed,
135                                            int stream_id,
136                                            RequestPriority request_priority,
137                                            spdy::SpdyControlType type,
138                                            spdy::SpdyControlFlags flags,
139                                            const char* const* kHeaders,
140                                            int kHeadersSize,
141                                            int associated_stream_id);
142 
143 // Construct an expected SPDY reply string.
144 // |extra_headers| are the extra header-value pairs, which typically
145 // will vary the most between calls.
146 // |buffer| is the buffer we're filling in.
147 // Returns the number of bytes written into |buffer|.
148 int ConstructSpdyReplyString(const char* const extra_headers[],
149                              int extra_header_count,
150                              char* buffer,
151                              int buffer_length);
152 
153 // Construct an expected SPDY SETTINGS frame.
154 // |settings| are the settings to set.
155 // Returns the constructed frame.  The caller takes ownership of the frame.
156 spdy::SpdyFrame* ConstructSpdySettings(spdy::SpdySettings settings);
157 
158 // Construct a SPDY PING frame.
159 // Returns the constructed frame.  The caller takes ownership of the frame.
160 spdy::SpdyFrame* ConstructSpdyPing();
161 
162 // Construct a SPDY GOAWAY frame.
163 // Returns the constructed frame.  The caller takes ownership of the frame.
164 spdy::SpdyFrame* ConstructSpdyGoAway();
165 
166 // Construct a SPDY WINDOW_UPDATE frame.
167 // Returns the constructed frame.  The caller takes ownership of the frame.
168 spdy::SpdyFrame* ConstructSpdyWindowUpdate(spdy::SpdyStreamId,
169                                            uint32 delta_window_size);
170 
171 // Construct a SPDY RST_STREAM frame.
172 // Returns the constructed frame.  The caller takes ownership of the frame.
173 spdy::SpdyFrame* ConstructSpdyRstStream(spdy::SpdyStreamId stream_id,
174                                         spdy::SpdyStatusCodes status);
175 
176 // Construct a single SPDY header entry, for validation.
177 // |extra_headers| are the extra header-value pairs.
178 // |buffer| is the buffer we're filling in.
179 // |index| is the index of the header we want.
180 // Returns the number of bytes written into |buffer|.
181 int ConstructSpdyHeader(const char* const extra_headers[],
182                         int extra_header_count,
183                         char* buffer,
184                         int buffer_length,
185                         int index);
186 
187 // Constructs a standard SPDY GET SYN packet, optionally compressed
188 // for the url |url|.
189 // |extra_headers| are the extra header-value pairs, which typically
190 // will vary the most between calls.
191 // Returns a SpdyFrame.
192 spdy::SpdyFrame* ConstructSpdyGet(const char* const url,
193                                   bool compressed,
194                                   int stream_id,
195                                   RequestPriority request_priority);
196 
197 // Constructs a standard SPDY GET SYN packet, optionally compressed.
198 // |extra_headers| are the extra header-value pairs, which typically
199 // will vary the most between calls.
200 // Returns a SpdyFrame.
201 spdy::SpdyFrame* ConstructSpdyGet(const char* const extra_headers[],
202                                   int extra_header_count,
203                                   bool compressed,
204                                   int stream_id,
205                                   RequestPriority request_priority);
206 
207 // Constructs a standard SPDY GET SYN packet, optionally compressed.
208 // |extra_headers| are the extra header-value pairs, which typically
209 // will vary the most between calls.  If |direct| is false, the
210 // the full url will be used instead of simply the path.
211 // Returns a SpdyFrame.
212 spdy::SpdyFrame* ConstructSpdyGet(const char* const extra_headers[],
213                                   int extra_header_count,
214                                   bool compressed,
215                                   int stream_id,
216                                   RequestPriority request_priority,
217                                   bool direct);
218 
219 // Constructs a standard SPDY SYN_STREAM frame for a CONNECT request.
220 spdy::SpdyFrame* ConstructSpdyConnect(const char* const extra_headers[],
221                                       int extra_header_count,
222                                       int stream_id);
223 
224 // Constructs a standard SPDY push SYN packet.
225 // |extra_headers| are the extra header-value pairs, which typically
226 // will vary the most between calls.
227 // Returns a SpdyFrame.
228 spdy::SpdyFrame* ConstructSpdyPush(const char* const extra_headers[],
229                                   int extra_header_count,
230                                   int stream_id,
231                                   int associated_stream_id);
232 spdy::SpdyFrame* ConstructSpdyPush(const char* const extra_headers[],
233                                   int extra_header_count,
234                                   int stream_id,
235                                   int associated_stream_id,
236                                   const char* url);
237 spdy::SpdyFrame* ConstructSpdyPush(const char* const extra_headers[],
238                                   int extra_header_count,
239                                   int stream_id,
240                                   int associated_stream_id,
241                                   const char* url,
242                                   const char* status,
243                                   const char* location);
244 spdy::SpdyFrame* ConstructSpdyPush(int stream_id,
245                                   int associated_stream_id,
246                                   const char* url);
247 
248 spdy::SpdyFrame* ConstructSpdyPushHeaders(int stream_id,
249                                           const char* const extra_headers[],
250                                           int extra_header_count);
251 
252 // Constructs a standard SPDY SYN_REPLY packet to match the SPDY GET.
253 // |extra_headers| are the extra header-value pairs, which typically
254 // will vary the most between calls.
255 // Returns a SpdyFrame.
256 spdy::SpdyFrame* ConstructSpdyGetSynReply(const char* const extra_headers[],
257                                           int extra_header_count,
258                                           int stream_id);
259 
260 // Constructs a standard SPDY SYN_REPLY packet to match the SPDY GET.
261 // |extra_headers| are the extra header-value pairs, which typically
262 // will vary the most between calls.
263 // Returns a SpdyFrame.
264 spdy::SpdyFrame* ConstructSpdyGetSynReplyRedirect(int stream_id);
265 
266 // Constructs a standard SPDY SYN_REPLY packet with an Internal Server
267 // Error status code.
268 // Returns a SpdyFrame.
269 spdy::SpdyFrame* ConstructSpdySynReplyError(int stream_id);
270 
271 // Constructs a standard SPDY SYN_REPLY packet with the specified status code.
272 // Returns a SpdyFrame.
273 spdy::SpdyFrame* ConstructSpdySynReplyError(
274     const char* const status,
275     const char* const* const extra_headers,
276     int extra_header_count,
277     int stream_id);
278 
279 // Constructs a standard SPDY POST SYN packet.
280 // |extra_headers| are the extra header-value pairs, which typically
281 // will vary the most between calls.
282 // Returns a SpdyFrame.
283 spdy::SpdyFrame* ConstructSpdyPost(int64 content_length,
284                                    const char* const extra_headers[],
285                                    int extra_header_count);
286 
287 // Constructs a chunked transfer SPDY POST SYN packet.
288 // |extra_headers| are the extra header-value pairs, which typically
289 // will vary the most between calls.
290 // Returns a SpdyFrame.
291 spdy::SpdyFrame* ConstructChunkedSpdyPost(const char* const extra_headers[],
292                                           int extra_header_count);
293 
294 // Constructs a standard SPDY SYN_REPLY packet to match the SPDY POST.
295 // |extra_headers| are the extra header-value pairs, which typically
296 // will vary the most between calls.
297 // Returns a SpdyFrame.
298 spdy::SpdyFrame* ConstructSpdyPostSynReply(const char* const extra_headers[],
299                                            int extra_header_count);
300 
301 // Constructs a single SPDY data frame with the contents "hello!"
302 spdy::SpdyFrame* ConstructSpdyBodyFrame(int stream_id,
303                                         bool fin);
304 
305 // Constructs a single SPDY data frame with the given content.
306 spdy::SpdyFrame* ConstructSpdyBodyFrame(int stream_id, const char* data,
307                                         uint32 len, bool fin);
308 
309 // Wraps |frame| in the payload of a data frame in stream |stream_id|.
310 spdy::SpdyFrame* ConstructWrappedSpdyFrame(
311     const scoped_ptr<spdy::SpdyFrame>& frame, int stream_id);
312 
313 // Create an async MockWrite from the given SpdyFrame.
314 MockWrite CreateMockWrite(const spdy::SpdyFrame& req);
315 
316 // Create an async MockWrite from the given SpdyFrame and sequence number.
317 MockWrite CreateMockWrite(const spdy::SpdyFrame& req, int seq);
318 
319 MockWrite CreateMockWrite(const spdy::SpdyFrame& req, int seq, bool async);
320 
321 // Create a MockRead from the given SpdyFrame.
322 MockRead CreateMockRead(const spdy::SpdyFrame& resp);
323 
324 // Create a MockRead from the given SpdyFrame and sequence number.
325 MockRead CreateMockRead(const spdy::SpdyFrame& resp, int seq);
326 
327 MockRead CreateMockRead(const spdy::SpdyFrame& resp, int seq, bool async);
328 
329 // Combines the given SpdyFrames into the given char array and returns
330 // the total length.
331 int CombineFrames(const spdy::SpdyFrame** frames, int num_frames,
332                   char* buff, int buff_len);
333 
334 // Helper to manage the lifetimes of the dependencies for a
335 // HttpNetworkTransaction.
336 class SpdySessionDependencies {
337  public:
338   // Default set of dependencies -- "null" proxy service.
339   SpdySessionDependencies();
340 
341   // Custom proxy service dependency.
342   explicit SpdySessionDependencies(ProxyService* proxy_service);
343 
344   ~SpdySessionDependencies();
345 
346   static HttpNetworkSession* SpdyCreateSession(
347       SpdySessionDependencies* session_deps);
348   static HttpNetworkSession* SpdyCreateSessionDeterministic(
349       SpdySessionDependencies* session_deps);
350 
351   // NOTE: host_resolver must be ordered before http_auth_handler_factory.
352   scoped_ptr<MockHostResolverBase> host_resolver;
353   scoped_ptr<CertVerifier> cert_verifier;
354   scoped_refptr<ProxyService> proxy_service;
355   scoped_refptr<SSLConfigService> ssl_config_service;
356   scoped_ptr<MockClientSocketFactory> socket_factory;
357   scoped_ptr<DeterministicMockClientSocketFactory> deterministic_socket_factory;
358   scoped_ptr<HttpAuthHandlerFactory> http_auth_handler_factory;
359 };
360 
361 class SpdyURLRequestContext : public URLRequestContext {
362  public:
363   SpdyURLRequestContext();
364 
socket_factory()365   MockClientSocketFactory& socket_factory() { return socket_factory_; }
366 
367  protected:
368   virtual ~SpdyURLRequestContext();
369 
370  private:
371   MockClientSocketFactory socket_factory_;
372 };
373 
374 const SpdyHeaderInfo make_spdy_header(spdy::SpdyControlType type);
375 }  // namespace net
376 
377 #endif  // NET_SPDY_SPDY_TEST_UTIL_H_
378