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 24namespace net { 25 26// Default upload data used by both, mock objects and framer when creating 27// data frames. 28const char kDefaultURL[] = "http://www.google.com"; 29const char kUploadData[] = "hello!"; 30const 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. 34struct 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. 51MockWrite* 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. 56MockWrite* 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. 62MockRead* 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. 67MockRead* 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|. 74void 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| 82template<class T> 83int 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 103int 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. 116spdy::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. 123spdy::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); 132spdy::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|. 148int 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. 156spdy::SpdyFrame* ConstructSpdySettings(spdy::SpdySettings settings); 157 158// Construct a SPDY PING frame. 159// Returns the constructed frame. The caller takes ownership of the frame. 160spdy::SpdyFrame* ConstructSpdyPing(); 161 162// Construct a SPDY GOAWAY frame. 163// Returns the constructed frame. The caller takes ownership of the frame. 164spdy::SpdyFrame* ConstructSpdyGoAway(); 165 166// Construct a SPDY WINDOW_UPDATE frame. 167// Returns the constructed frame. The caller takes ownership of the frame. 168spdy::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. 173spdy::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|. 181int 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. 192spdy::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. 201spdy::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. 212spdy::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. 220spdy::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. 228spdy::SpdyFrame* ConstructSpdyPush(const char* const extra_headers[], 229 int extra_header_count, 230 int stream_id, 231 int associated_stream_id); 232spdy::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); 237spdy::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); 244spdy::SpdyFrame* ConstructSpdyPush(int stream_id, 245 int associated_stream_id, 246 const char* url); 247 248spdy::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. 256spdy::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. 264spdy::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. 269spdy::SpdyFrame* ConstructSpdySynReplyError(int stream_id); 270 271// Constructs a standard SPDY SYN_REPLY packet with the specified status code. 272// Returns a SpdyFrame. 273spdy::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. 283spdy::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. 291spdy::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. 298spdy::SpdyFrame* ConstructSpdyPostSynReply(const char* const extra_headers[], 299 int extra_header_count); 300 301// Constructs a single SPDY data frame with the contents "hello!" 302spdy::SpdyFrame* ConstructSpdyBodyFrame(int stream_id, 303 bool fin); 304 305// Constructs a single SPDY data frame with the given content. 306spdy::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|. 310spdy::SpdyFrame* ConstructWrappedSpdyFrame( 311 const scoped_ptr<spdy::SpdyFrame>& frame, int stream_id); 312 313// Create an async MockWrite from the given SpdyFrame. 314MockWrite CreateMockWrite(const spdy::SpdyFrame& req); 315 316// Create an async MockWrite from the given SpdyFrame and sequence number. 317MockWrite CreateMockWrite(const spdy::SpdyFrame& req, int seq); 318 319MockWrite CreateMockWrite(const spdy::SpdyFrame& req, int seq, bool async); 320 321// Create a MockRead from the given SpdyFrame. 322MockRead CreateMockRead(const spdy::SpdyFrame& resp); 323 324// Create a MockRead from the given SpdyFrame and sequence number. 325MockRead CreateMockRead(const spdy::SpdyFrame& resp, int seq); 326 327MockRead 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. 331int 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. 336class 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 361class SpdyURLRequestContext : public URLRequestContext { 362 public: 363 SpdyURLRequestContext(); 364 365 MockClientSocketFactory& socket_factory() { return socket_factory_; } 366 367 protected: 368 virtual ~SpdyURLRequestContext(); 369 370 private: 371 MockClientSocketFactory socket_factory_; 372}; 373 374const SpdyHeaderInfo make_spdy_header(spdy::SpdyControlType type); 375} // namespace net 376 377#endif // NET_SPDY_SPDY_TEST_UTIL_H_ 378