Switch global error menu icon to vectorized MD asset
[chromium-blink-merge.git] / net / spdy / spdy_test_util_common.cc
blob7fe1896e24d38751cf1066bd0a513bb83d6ad64b
1 // Copyright (c) 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.
5 #include "net/spdy/spdy_test_util_common.h"
7 #include <cstddef>
9 #include "base/compiler_specific.h"
10 #include "base/memory/scoped_ptr.h"
11 #include "base/strings/string_number_conversions.h"
12 #include "base/strings/string_split.h"
13 #include "net/cert/mock_cert_verifier.h"
14 #include "net/http/http_cache.h"
15 #include "net/http/http_network_session.h"
16 #include "net/http/http_network_transaction.h"
17 #include "net/http/http_server_properties_impl.h"
18 #include "net/socket/socket_test_util.h"
19 #include "net/socket/ssl_client_socket.h"
20 #include "net/socket/transport_client_socket_pool.h"
21 #include "net/spdy/buffered_spdy_framer.h"
22 #include "net/spdy/spdy_framer.h"
23 #include "net/spdy/spdy_http_utils.h"
24 #include "net/spdy/spdy_session.h"
25 #include "net/spdy/spdy_session_pool.h"
26 #include "net/spdy/spdy_stream.h"
27 #include "net/url_request/url_request_job_factory_impl.h"
29 namespace net {
31 namespace {
33 bool next_proto_is_spdy(NextProto next_proto) {
34 return next_proto >= kProtoSPDYMinimumVersion &&
35 next_proto <= kProtoSPDYMaximumVersion;
38 // Parses a URL into the scheme, host, and path components required for a
39 // SPDY request.
40 void ParseUrl(base::StringPiece url, std::string* scheme, std::string* host,
41 std::string* path) {
42 GURL gurl(url.as_string());
43 path->assign(gurl.PathForRequest());
44 scheme->assign(gurl.scheme());
45 host->assign(gurl.host());
46 if (gurl.has_port()) {
47 host->append(":");
48 host->append(gurl.port());
52 } // namespace
54 NextProtoVector SpdyNextProtos() {
55 NextProtoVector next_protos;
56 next_protos.push_back(kProtoHTTP11);
57 next_protos.push_back(kProtoSPDY31);
58 next_protos.push_back(kProtoHTTP2);
59 next_protos.push_back(kProtoQUIC1SPDY3);
60 return next_protos;
63 // Chop a frame into an array of MockWrites.
64 // |data| is the frame to chop.
65 // |length| is the length of the frame to chop.
66 // |num_chunks| is the number of chunks to create.
67 MockWrite* ChopWriteFrame(const char* data, int length, int num_chunks) {
68 MockWrite* chunks = new MockWrite[num_chunks];
69 int chunk_size = length / num_chunks;
70 for (int index = 0; index < num_chunks; index++) {
71 const char* ptr = data + (index * chunk_size);
72 if (index == num_chunks - 1)
73 chunk_size += length % chunk_size; // The last chunk takes the remainder.
74 chunks[index] = MockWrite(ASYNC, ptr, chunk_size);
76 return chunks;
79 // Chop a SpdyFrame into an array of MockWrites.
80 // |frame| is the frame to chop.
81 // |num_chunks| is the number of chunks to create.
82 MockWrite* ChopWriteFrame(const SpdyFrame& frame, int num_chunks) {
83 return ChopWriteFrame(frame.data(), frame.size(), num_chunks);
86 // Chop a frame into an array of MockReads.
87 // |data| is the frame to chop.
88 // |length| is the length of the frame to chop.
89 // |num_chunks| is the number of chunks to create.
90 MockRead* ChopReadFrame(const char* data, int length, int num_chunks) {
91 MockRead* chunks = new MockRead[num_chunks];
92 int chunk_size = length / num_chunks;
93 for (int index = 0; index < num_chunks; index++) {
94 const char* ptr = data + (index * chunk_size);
95 if (index == num_chunks - 1)
96 chunk_size += length % chunk_size; // The last chunk takes the remainder.
97 chunks[index] = MockRead(ASYNC, ptr, chunk_size);
99 return chunks;
102 // Chop a SpdyFrame into an array of MockReads.
103 // |frame| is the frame to chop.
104 // |num_chunks| is the number of chunks to create.
105 MockRead* ChopReadFrame(const SpdyFrame& frame, int num_chunks) {
106 return ChopReadFrame(frame.data(), frame.size(), num_chunks);
109 // Adds headers and values to a map.
110 // |extra_headers| is an array of { name, value } pairs, arranged as strings
111 // where the even entries are the header names, and the odd entries are the
112 // header values.
113 // |headers| gets filled in from |extra_headers|.
114 void AppendToHeaderBlock(const char* const extra_headers[],
115 int extra_header_count,
116 SpdyHeaderBlock* headers) {
117 std::string this_header;
118 std::string this_value;
120 if (!extra_header_count)
121 return;
123 // Sanity check: Non-NULL header list.
124 DCHECK(NULL != extra_headers) << "NULL header value pair list";
125 // Sanity check: Non-NULL header map.
126 DCHECK(NULL != headers) << "NULL header map";
127 // Copy in the headers.
128 for (int i = 0; i < extra_header_count; i++) {
129 // Sanity check: Non-empty header.
130 DCHECK_NE('\0', *extra_headers[i * 2]) << "Empty header value pair";
131 this_header = extra_headers[i * 2];
132 std::string::size_type header_len = this_header.length();
133 if (!header_len)
134 continue;
135 this_value = extra_headers[1 + (i * 2)];
136 std::string new_value;
137 if (headers->find(this_header) != headers->end()) {
138 // More than one entry in the header.
139 // Don't add the header again, just the append to the value,
140 // separated by a NULL character.
142 // Adjust the value.
143 new_value = (*headers)[this_header];
144 // Put in a NULL separator.
145 new_value.append(1, '\0');
146 // Append the new value.
147 new_value += this_value;
148 } else {
149 // Not a duplicate, just write the value.
150 new_value = this_value;
152 (*headers)[this_header] = new_value;
156 // Create a MockWrite from the given SpdyFrame.
157 MockWrite CreateMockWrite(const SpdyFrame& req) {
158 return MockWrite(ASYNC, req.data(), req.size());
161 // Create a MockWrite from the given SpdyFrame and sequence number.
162 MockWrite CreateMockWrite(const SpdyFrame& req, int seq) {
163 return CreateMockWrite(req, seq, ASYNC);
166 // Create a MockWrite from the given SpdyFrame and sequence number.
167 MockWrite CreateMockWrite(const SpdyFrame& req, int seq, IoMode mode) {
168 return MockWrite(mode, req.data(), req.size(), seq);
171 // Create a MockRead from the given SpdyFrame.
172 MockRead CreateMockRead(const SpdyFrame& resp) {
173 return MockRead(ASYNC, resp.data(), resp.size());
176 // Create a MockRead from the given SpdyFrame and sequence number.
177 MockRead CreateMockRead(const SpdyFrame& resp, int seq) {
178 return CreateMockRead(resp, seq, ASYNC);
181 // Create a MockRead from the given SpdyFrame and sequence number.
182 MockRead CreateMockRead(const SpdyFrame& resp, int seq, IoMode mode) {
183 return MockRead(mode, resp.data(), resp.size(), seq);
186 // Combines the given SpdyFrames into the given char array and returns
187 // the total length.
188 int CombineFrames(const SpdyFrame** frames, int num_frames,
189 char* buff, int buff_len) {
190 int total_len = 0;
191 for (int i = 0; i < num_frames; ++i) {
192 total_len += frames[i]->size();
194 DCHECK_LE(total_len, buff_len);
195 char* ptr = buff;
196 for (int i = 0; i < num_frames; ++i) {
197 int len = frames[i]->size();
198 memcpy(ptr, frames[i]->data(), len);
199 ptr += len;
201 return total_len;
204 namespace {
206 class PriorityGetter : public BufferedSpdyFramerVisitorInterface {
207 public:
208 PriorityGetter() : priority_(0) {}
209 ~PriorityGetter() override {}
211 SpdyPriority priority() const {
212 return priority_;
215 void OnError(SpdyFramer::SpdyError error_code) override {}
216 void OnStreamError(SpdyStreamId stream_id,
217 const std::string& description) override {}
218 void OnSynStream(SpdyStreamId stream_id,
219 SpdyStreamId associated_stream_id,
220 SpdyPriority priority,
221 bool fin,
222 bool unidirectional,
223 const SpdyHeaderBlock& headers) override {
224 priority_ = priority;
226 void OnSynReply(SpdyStreamId stream_id,
227 bool fin,
228 const SpdyHeaderBlock& headers) override {}
229 void OnHeaders(SpdyStreamId stream_id,
230 bool has_priority,
231 SpdyPriority priority,
232 SpdyStreamId parent_stream_id,
233 bool exclusive,
234 bool fin,
235 const SpdyHeaderBlock& headers) override {
236 if (has_priority) {
237 priority_ = priority;
240 void OnDataFrameHeader(SpdyStreamId stream_id,
241 size_t length,
242 bool fin) override {}
243 void OnStreamFrameData(SpdyStreamId stream_id,
244 const char* data,
245 size_t len,
246 bool fin) override {}
247 void OnStreamPadding(SpdyStreamId stream_id, size_t len) override {}
248 void OnSettings(bool clear_persisted) override {}
249 void OnSetting(SpdySettingsIds id, uint8 flags, uint32 value) override {}
250 void OnPing(SpdyPingId unique_id, bool is_ack) override {}
251 void OnRstStream(SpdyStreamId stream_id,
252 SpdyRstStreamStatus status) override {}
253 void OnGoAway(SpdyStreamId last_accepted_stream_id,
254 SpdyGoAwayStatus status) override {}
255 void OnWindowUpdate(SpdyStreamId stream_id, int delta_window_size) override {}
256 void OnPushPromise(SpdyStreamId stream_id,
257 SpdyStreamId promised_stream_id,
258 const SpdyHeaderBlock& headers) override {}
259 bool OnUnknownFrame(SpdyStreamId stream_id, int frame_type) override {
260 return false;
263 private:
264 SpdyPriority priority_;
267 } // namespace
269 bool GetSpdyPriority(SpdyMajorVersion version,
270 const SpdyFrame& frame,
271 SpdyPriority* priority) {
272 BufferedSpdyFramer framer(version, false);
273 PriorityGetter priority_getter;
274 framer.set_visitor(&priority_getter);
275 size_t frame_size = frame.size();
276 if (framer.ProcessInput(frame.data(), frame_size) != frame_size) {
277 return false;
279 *priority = priority_getter.priority();
280 return true;
283 base::WeakPtr<SpdyStream> CreateStreamSynchronously(
284 SpdyStreamType type,
285 const base::WeakPtr<SpdySession>& session,
286 const GURL& url,
287 RequestPriority priority,
288 const BoundNetLog& net_log) {
289 SpdyStreamRequest stream_request;
290 int rv = stream_request.StartRequest(type, session, url, priority, net_log,
291 CompletionCallback());
292 return
293 (rv == OK) ? stream_request.ReleaseStream() : base::WeakPtr<SpdyStream>();
296 StreamReleaserCallback::StreamReleaserCallback() {}
298 StreamReleaserCallback::~StreamReleaserCallback() {}
300 CompletionCallback StreamReleaserCallback::MakeCallback(
301 SpdyStreamRequest* request) {
302 return base::Bind(&StreamReleaserCallback::OnComplete,
303 base::Unretained(this),
304 request);
307 void StreamReleaserCallback::OnComplete(
308 SpdyStreamRequest* request, int result) {
309 if (result == OK)
310 request->ReleaseStream()->Cancel();
311 SetResult(result);
314 MockECSignatureCreator::MockECSignatureCreator(crypto::ECPrivateKey* key)
315 : key_(key) {
318 bool MockECSignatureCreator::Sign(const uint8* data,
319 int data_len,
320 std::vector<uint8>* signature) {
321 std::vector<uint8> private_key_value;
322 key_->ExportValue(&private_key_value);
323 std::string head = "fakesignature";
324 std::string tail = "/fakesignature";
326 signature->clear();
327 signature->insert(signature->end(), head.begin(), head.end());
328 signature->insert(signature->end(), private_key_value.begin(),
329 private_key_value.end());
330 signature->insert(signature->end(), '-');
331 signature->insert(signature->end(), data, data + data_len);
332 signature->insert(signature->end(), tail.begin(), tail.end());
333 return true;
336 bool MockECSignatureCreator::DecodeSignature(
337 const std::vector<uint8>& signature,
338 std::vector<uint8>* out_raw_sig) {
339 *out_raw_sig = signature;
340 return true;
343 MockECSignatureCreatorFactory::MockECSignatureCreatorFactory() {
344 crypto::ECSignatureCreator::SetFactoryForTesting(this);
347 MockECSignatureCreatorFactory::~MockECSignatureCreatorFactory() {
348 crypto::ECSignatureCreator::SetFactoryForTesting(NULL);
351 crypto::ECSignatureCreator* MockECSignatureCreatorFactory::Create(
352 crypto::ECPrivateKey* key) {
353 return new MockECSignatureCreator(key);
356 SpdySessionDependencies::SpdySessionDependencies(NextProto protocol)
357 : host_resolver(new MockCachingHostResolver),
358 cert_verifier(new MockCertVerifier),
359 transport_security_state(new TransportSecurityState),
360 proxy_service(ProxyService::CreateDirect()),
361 ssl_config_service(new SSLConfigServiceDefaults),
362 socket_factory(new MockClientSocketFactory),
363 deterministic_socket_factory(new DeterministicMockClientSocketFactory),
364 http_auth_handler_factory(
365 HttpAuthHandlerFactory::CreateDefault(host_resolver.get())),
366 enable_ip_pooling(true),
367 enable_compression(false),
368 enable_ping(false),
369 enable_user_alternate_protocol_ports(false),
370 protocol(protocol),
371 session_max_recv_window_size(
372 SpdySession::GetDefaultInitialWindowSize(protocol)),
373 stream_max_recv_window_size(
374 SpdySession::GetDefaultInitialWindowSize(protocol)),
375 time_func(&base::TimeTicks::Now),
376 use_alternative_services(false),
377 net_log(NULL) {
378 DCHECK(next_proto_is_spdy(protocol)) << "Invalid protocol: " << protocol;
380 // Note: The CancelledTransaction test does cleanup by running all
381 // tasks in the message loop (RunAllPending). Unfortunately, that
382 // doesn't clean up tasks on the host resolver thread; and
383 // TCPConnectJob is currently not cancellable. Using synchronous
384 // lookups allows the test to shutdown cleanly. Until we have
385 // cancellable TCPConnectJobs, use synchronous lookups.
386 host_resolver->set_synchronous_mode(true);
389 SpdySessionDependencies::SpdySessionDependencies(NextProto protocol,
390 ProxyService* proxy_service)
391 : host_resolver(new MockHostResolver),
392 cert_verifier(new MockCertVerifier),
393 transport_security_state(new TransportSecurityState),
394 proxy_service(proxy_service),
395 ssl_config_service(new SSLConfigServiceDefaults),
396 socket_factory(new MockClientSocketFactory),
397 deterministic_socket_factory(new DeterministicMockClientSocketFactory),
398 http_auth_handler_factory(
399 HttpAuthHandlerFactory::CreateDefault(host_resolver.get())),
400 enable_ip_pooling(true),
401 enable_compression(false),
402 enable_ping(false),
403 enable_user_alternate_protocol_ports(false),
404 protocol(protocol),
405 session_max_recv_window_size(
406 SpdySession::GetDefaultInitialWindowSize(protocol)),
407 stream_max_recv_window_size(
408 SpdySession::GetDefaultInitialWindowSize(protocol)),
409 time_func(&base::TimeTicks::Now),
410 use_alternative_services(true),
411 net_log(NULL) {
412 DCHECK(next_proto_is_spdy(protocol)) << "Invalid protocol: " << protocol;
415 SpdySessionDependencies::~SpdySessionDependencies() {}
417 // static
418 HttpNetworkSession* SpdySessionDependencies::SpdyCreateSession(
419 SpdySessionDependencies* session_deps) {
420 HttpNetworkSession::Params params = CreateSessionParams(session_deps);
421 params.client_socket_factory = session_deps->socket_factory.get();
422 HttpNetworkSession* http_session = new HttpNetworkSession(params);
423 SpdySessionPoolPeer pool_peer(http_session->spdy_session_pool());
424 pool_peer.SetEnableSendingInitialData(false);
425 return http_session;
428 // static
429 HttpNetworkSession* SpdySessionDependencies::SpdyCreateSessionDeterministic(
430 SpdySessionDependencies* session_deps) {
431 HttpNetworkSession::Params params = CreateSessionParams(session_deps);
432 params.client_socket_factory =
433 session_deps->deterministic_socket_factory.get();
434 HttpNetworkSession* http_session = new HttpNetworkSession(params);
435 SpdySessionPoolPeer pool_peer(http_session->spdy_session_pool());
436 pool_peer.SetEnableSendingInitialData(false);
437 return http_session;
440 // static
441 HttpNetworkSession::Params SpdySessionDependencies::CreateSessionParams(
442 SpdySessionDependencies* session_deps) {
443 DCHECK(next_proto_is_spdy(session_deps->protocol)) <<
444 "Invalid protocol: " << session_deps->protocol;
446 HttpNetworkSession::Params params;
447 params.host_resolver = session_deps->host_resolver.get();
448 params.cert_verifier = session_deps->cert_verifier.get();
449 params.transport_security_state =
450 session_deps->transport_security_state.get();
451 params.proxy_service = session_deps->proxy_service.get();
452 params.ssl_config_service = session_deps->ssl_config_service.get();
453 params.http_auth_handler_factory =
454 session_deps->http_auth_handler_factory.get();
455 params.http_server_properties =
456 session_deps->http_server_properties.GetWeakPtr();
457 params.enable_spdy_compression = session_deps->enable_compression;
458 params.enable_spdy_ping_based_connection_checking = session_deps->enable_ping;
459 params.enable_user_alternate_protocol_ports =
460 session_deps->enable_user_alternate_protocol_ports;
461 params.spdy_default_protocol = session_deps->protocol;
462 params.spdy_session_max_recv_window_size =
463 session_deps->session_max_recv_window_size;
464 params.spdy_stream_max_recv_window_size =
465 session_deps->stream_max_recv_window_size;
466 params.time_func = session_deps->time_func;
467 params.next_protos = session_deps->next_protos;
468 params.trusted_spdy_proxy = session_deps->trusted_spdy_proxy;
469 params.use_alternative_services = session_deps->use_alternative_services;
470 params.net_log = session_deps->net_log;
471 return params;
474 SpdyURLRequestContext::SpdyURLRequestContext(NextProto protocol)
475 : storage_(this) {
476 DCHECK(next_proto_is_spdy(protocol)) << "Invalid protocol: " << protocol;
478 storage_.set_host_resolver(scoped_ptr<HostResolver>(new MockHostResolver));
479 storage_.set_cert_verifier(new MockCertVerifier);
480 storage_.set_transport_security_state(new TransportSecurityState);
481 storage_.set_proxy_service(ProxyService::CreateDirect());
482 storage_.set_ssl_config_service(new SSLConfigServiceDefaults);
483 storage_.set_http_auth_handler_factory(HttpAuthHandlerFactory::CreateDefault(
484 host_resolver()));
485 storage_.set_http_server_properties(
486 scoped_ptr<HttpServerProperties>(new HttpServerPropertiesImpl()));
487 storage_.set_job_factory(new URLRequestJobFactoryImpl());
488 HttpNetworkSession::Params params;
489 params.client_socket_factory = &socket_factory_;
490 params.host_resolver = host_resolver();
491 params.cert_verifier = cert_verifier();
492 params.transport_security_state = transport_security_state();
493 params.proxy_service = proxy_service();
494 params.ssl_config_service = ssl_config_service();
495 params.http_auth_handler_factory = http_auth_handler_factory();
496 params.network_delegate = network_delegate();
497 params.enable_spdy_compression = false;
498 params.enable_spdy_ping_based_connection_checking = false;
499 params.spdy_default_protocol = protocol;
500 params.http_server_properties = http_server_properties();
501 scoped_refptr<HttpNetworkSession> network_session(
502 new HttpNetworkSession(params));
503 SpdySessionPoolPeer pool_peer(network_session->spdy_session_pool());
504 pool_peer.SetEnableSendingInitialData(false);
505 storage_.set_http_transaction_factory(new HttpCache(
506 network_session.get(), HttpCache::DefaultBackend::InMemory(0)));
509 SpdyURLRequestContext::~SpdyURLRequestContext() {
510 AssertNoURLRequests();
513 bool HasSpdySession(SpdySessionPool* pool, const SpdySessionKey& key) {
514 return pool->FindAvailableSession(key, BoundNetLog()) != NULL;
517 namespace {
519 base::WeakPtr<SpdySession> CreateSpdySessionHelper(
520 const scoped_refptr<HttpNetworkSession>& http_session,
521 const SpdySessionKey& key,
522 const BoundNetLog& net_log,
523 Error expected_status,
524 bool is_secure) {
525 EXPECT_FALSE(HasSpdySession(http_session->spdy_session_pool(), key));
527 scoped_refptr<TransportSocketParams> transport_params(
528 new TransportSocketParams(
529 key.host_port_pair(), false, false, OnHostResolutionCallback(),
530 TransportSocketParams::COMBINE_CONNECT_AND_WRITE_DEFAULT));
532 scoped_ptr<ClientSocketHandle> connection(new ClientSocketHandle);
533 TestCompletionCallback callback;
535 int rv = ERR_UNEXPECTED;
536 if (is_secure) {
537 SSLConfig ssl_config;
538 scoped_refptr<SSLSocketParams> ssl_params(
539 new SSLSocketParams(transport_params,
540 NULL,
541 NULL,
542 key.host_port_pair(),
543 ssl_config,
544 key.privacy_mode(),
546 false));
547 rv = connection->Init(key.host_port_pair().ToString(),
548 ssl_params,
549 MEDIUM,
550 callback.callback(),
551 http_session->GetSSLSocketPool(
552 HttpNetworkSession::NORMAL_SOCKET_POOL),
553 net_log);
554 } else {
555 rv = connection->Init(key.host_port_pair().ToString(),
556 transport_params,
557 MEDIUM,
558 callback.callback(),
559 http_session->GetTransportSocketPool(
560 HttpNetworkSession::NORMAL_SOCKET_POOL),
561 net_log);
564 if (rv == ERR_IO_PENDING)
565 rv = callback.WaitForResult();
567 EXPECT_EQ(OK, rv);
569 base::WeakPtr<SpdySession> spdy_session =
570 http_session->spdy_session_pool()->CreateAvailableSessionFromSocket(
571 key, connection.Pass(), net_log, OK, is_secure);
572 // Failure is reported asynchronously.
573 EXPECT_TRUE(spdy_session != NULL);
574 EXPECT_TRUE(HasSpdySession(http_session->spdy_session_pool(), key));
575 return spdy_session;
578 } // namespace
580 base::WeakPtr<SpdySession> CreateInsecureSpdySession(
581 const scoped_refptr<HttpNetworkSession>& http_session,
582 const SpdySessionKey& key,
583 const BoundNetLog& net_log) {
584 return CreateSpdySessionHelper(http_session, key, net_log,
585 OK, false /* is_secure */);
588 base::WeakPtr<SpdySession> TryCreateInsecureSpdySessionExpectingFailure(
589 const scoped_refptr<HttpNetworkSession>& http_session,
590 const SpdySessionKey& key,
591 Error expected_error,
592 const BoundNetLog& net_log) {
593 DCHECK_LT(expected_error, ERR_IO_PENDING);
594 return CreateSpdySessionHelper(http_session, key, net_log,
595 expected_error, false /* is_secure */);
598 base::WeakPtr<SpdySession> CreateSecureSpdySession(
599 const scoped_refptr<HttpNetworkSession>& http_session,
600 const SpdySessionKey& key,
601 const BoundNetLog& net_log) {
602 return CreateSpdySessionHelper(http_session, key, net_log,
603 OK, true /* is_secure */);
606 namespace {
608 // A ClientSocket used for CreateFakeSpdySession() below.
609 class FakeSpdySessionClientSocket : public MockClientSocket {
610 public:
611 explicit FakeSpdySessionClientSocket(int read_result)
612 : MockClientSocket(BoundNetLog()), read_result_(read_result) {}
614 ~FakeSpdySessionClientSocket() override {}
616 int Read(IOBuffer* buf,
617 int buf_len,
618 const CompletionCallback& callback) override {
619 return read_result_;
622 int Write(IOBuffer* buf,
623 int buf_len,
624 const CompletionCallback& callback) override {
625 return ERR_IO_PENDING;
628 // Return kProtoUnknown to use the pool's default protocol.
629 NextProto GetNegotiatedProtocol() const override { return kProtoUnknown; }
631 // The functions below are not expected to be called.
633 int Connect(const CompletionCallback& callback) override {
634 ADD_FAILURE();
635 return ERR_UNEXPECTED;
638 bool WasEverUsed() const override {
639 ADD_FAILURE();
640 return false;
643 bool UsingTCPFastOpen() const override {
644 ADD_FAILURE();
645 return false;
648 bool WasNpnNegotiated() const override {
649 ADD_FAILURE();
650 return false;
653 bool GetSSLInfo(SSLInfo* ssl_info) override {
654 ADD_FAILURE();
655 return false;
658 private:
659 int read_result_;
662 base::WeakPtr<SpdySession> CreateFakeSpdySessionHelper(
663 SpdySessionPool* pool,
664 const SpdySessionKey& key,
665 Error expected_status) {
666 EXPECT_NE(expected_status, ERR_IO_PENDING);
667 EXPECT_FALSE(HasSpdySession(pool, key));
668 scoped_ptr<ClientSocketHandle> handle(new ClientSocketHandle());
669 handle->SetSocket(scoped_ptr<StreamSocket>(new FakeSpdySessionClientSocket(
670 expected_status == OK ? ERR_IO_PENDING : expected_status)));
671 base::WeakPtr<SpdySession> spdy_session =
672 pool->CreateAvailableSessionFromSocket(
673 key, handle.Pass(), BoundNetLog(), OK, true /* is_secure */);
674 // Failure is reported asynchronously.
675 EXPECT_TRUE(spdy_session != NULL);
676 EXPECT_TRUE(HasSpdySession(pool, key));
677 return spdy_session;
680 } // namespace
682 base::WeakPtr<SpdySession> CreateFakeSpdySession(SpdySessionPool* pool,
683 const SpdySessionKey& key) {
684 return CreateFakeSpdySessionHelper(pool, key, OK);
687 base::WeakPtr<SpdySession> TryCreateFakeSpdySessionExpectingFailure(
688 SpdySessionPool* pool,
689 const SpdySessionKey& key,
690 Error expected_error) {
691 DCHECK_LT(expected_error, ERR_IO_PENDING);
692 return CreateFakeSpdySessionHelper(pool, key, expected_error);
695 SpdySessionPoolPeer::SpdySessionPoolPeer(SpdySessionPool* pool) : pool_(pool) {
698 void SpdySessionPoolPeer::RemoveAliases(const SpdySessionKey& key) {
699 pool_->RemoveAliases(key);
702 void SpdySessionPoolPeer::DisableDomainAuthenticationVerification() {
703 pool_->verify_domain_authentication_ = false;
706 void SpdySessionPoolPeer::SetEnableSendingInitialData(bool enabled) {
707 pool_->enable_sending_initial_data_ = enabled;
710 void SpdySessionPoolPeer::SetSessionMaxRecvWindowSize(size_t window) {
711 pool_->session_max_recv_window_size_ = window;
714 void SpdySessionPoolPeer::SetStreamInitialRecvWindowSize(size_t window) {
715 pool_->stream_max_recv_window_size_ = window;
718 SpdyTestUtil::SpdyTestUtil(NextProto protocol)
719 : protocol_(protocol),
720 spdy_version_(NextProtoToSpdyMajorVersion(protocol)),
721 default_url_(GURL(kDefaultURL)) {
722 DCHECK(next_proto_is_spdy(protocol)) << "Invalid protocol: " << protocol;
725 void SpdyTestUtil::AddUrlToHeaderBlock(base::StringPiece url,
726 SpdyHeaderBlock* headers) const {
727 std::string scheme, host, path;
728 ParseUrl(url, &scheme, &host, &path);
729 (*headers)[GetSchemeKey()] = scheme;
730 (*headers)[GetHostKey()] = host;
731 (*headers)[GetPathKey()] = path;
734 scoped_ptr<SpdyHeaderBlock> SpdyTestUtil::ConstructGetHeaderBlock(
735 base::StringPiece url) const {
736 return ConstructHeaderBlock("GET", url, NULL);
739 scoped_ptr<SpdyHeaderBlock> SpdyTestUtil::ConstructGetHeaderBlockForProxy(
740 base::StringPiece url) const {
741 scoped_ptr<SpdyHeaderBlock> headers(ConstructGetHeaderBlock(url));
742 return headers.Pass();
745 scoped_ptr<SpdyHeaderBlock> SpdyTestUtil::ConstructHeadHeaderBlock(
746 base::StringPiece url,
747 int64 content_length) const {
748 return ConstructHeaderBlock("HEAD", url, nullptr);
751 scoped_ptr<SpdyHeaderBlock> SpdyTestUtil::ConstructPostHeaderBlock(
752 base::StringPiece url,
753 int64 content_length) const {
754 return ConstructHeaderBlock("POST", url, &content_length);
757 scoped_ptr<SpdyHeaderBlock> SpdyTestUtil::ConstructPutHeaderBlock(
758 base::StringPiece url,
759 int64 content_length) const {
760 return ConstructHeaderBlock("PUT", url, &content_length);
763 SpdyFrame* SpdyTestUtil::ConstructSpdyFrame(
764 const SpdyHeaderInfo& header_info,
765 scoped_ptr<SpdyHeaderBlock> headers) const {
766 BufferedSpdyFramer framer(spdy_version_, header_info.compressed);
767 SpdyFrame* frame = NULL;
768 switch (header_info.kind) {
769 case DATA:
770 frame = framer.CreateDataFrame(header_info.id, header_info.data,
771 header_info.data_length,
772 header_info.data_flags);
773 break;
774 case SYN_STREAM:
776 frame = framer.CreateSynStream(header_info.id, header_info.assoc_id,
777 header_info.priority,
778 header_info.control_flags,
779 headers.get());
781 break;
782 case SYN_REPLY:
783 frame = framer.CreateSynReply(header_info.id, header_info.control_flags,
784 headers.get());
785 break;
786 case RST_STREAM:
787 frame = framer.CreateRstStream(header_info.id, header_info.status);
788 break;
789 case HEADERS:
790 frame = framer.CreateHeaders(header_info.id, header_info.control_flags,
791 header_info.priority,
792 headers.get());
793 break;
794 default:
795 ADD_FAILURE();
796 break;
798 return frame;
801 SpdyFrame* SpdyTestUtil::ConstructSpdyFrame(const SpdyHeaderInfo& header_info,
802 const char* const extra_headers[],
803 int extra_header_count,
804 const char* const tail_headers[],
805 int tail_header_count) const {
806 scoped_ptr<SpdyHeaderBlock> headers(new SpdyHeaderBlock());
807 AppendToHeaderBlock(extra_headers, extra_header_count, headers.get());
808 if (tail_headers && tail_header_count)
809 AppendToHeaderBlock(tail_headers, tail_header_count, headers.get());
810 return ConstructSpdyFrame(header_info, headers.Pass());
813 SpdyFrame* SpdyTestUtil::ConstructSpdyControlFrame(
814 scoped_ptr<SpdyHeaderBlock> headers,
815 bool compressed,
816 SpdyStreamId stream_id,
817 RequestPriority request_priority,
818 SpdyFrameType type,
819 SpdyControlFlags flags,
820 SpdyStreamId associated_stream_id) const {
821 EXPECT_GE(type, DATA);
822 EXPECT_LE(type, PRIORITY);
823 const SpdyHeaderInfo header_info = {
824 type,
825 stream_id,
826 associated_stream_id,
827 ConvertRequestPriorityToSpdyPriority(request_priority, spdy_version_),
828 0, // credential slot
829 flags,
830 compressed,
831 RST_STREAM_INVALID, // status
832 NULL, // data
833 0, // length
834 DATA_FLAG_NONE
836 return ConstructSpdyFrame(header_info, headers.Pass());
839 SpdyFrame* SpdyTestUtil::ConstructSpdyControlFrame(
840 const char* const extra_headers[],
841 int extra_header_count,
842 bool compressed,
843 SpdyStreamId stream_id,
844 RequestPriority request_priority,
845 SpdyFrameType type,
846 SpdyControlFlags flags,
847 const char* const* tail_headers,
848 int tail_header_size,
849 SpdyStreamId associated_stream_id) const {
850 scoped_ptr<SpdyHeaderBlock> headers(new SpdyHeaderBlock());
851 AppendToHeaderBlock(extra_headers, extra_header_count, headers.get());
852 if (tail_headers && tail_header_size)
853 AppendToHeaderBlock(tail_headers, tail_header_size / 2, headers.get());
854 return ConstructSpdyControlFrame(
855 headers.Pass(), compressed, stream_id,
856 request_priority, type, flags, associated_stream_id);
859 std::string SpdyTestUtil::ConstructSpdyReplyString(
860 const SpdyHeaderBlock& headers) const {
861 std::string reply_string;
862 for (SpdyHeaderBlock::const_iterator it = headers.begin();
863 it != headers.end(); ++it) {
864 std::string key = it->first;
865 // Remove leading colon from "special" headers (for SPDY3 and
866 // above).
867 if (spdy_version() >= SPDY3 && key[0] == ':')
868 key = key.substr(1);
869 for (const std::string& value :
870 base::SplitString(it->second, base::StringPiece("\0", 1),
871 base::TRIM_WHITESPACE, base::SPLIT_WANT_ALL)) {
872 reply_string += key + ": " + value + "\n";
875 return reply_string;
878 // TODO(jgraettinger): Eliminate uses of this method in tests (prefer
879 // SpdySettingsIR).
880 SpdyFrame* SpdyTestUtil::ConstructSpdySettings(
881 const SettingsMap& settings) const {
882 SpdySettingsIR settings_ir;
883 for (SettingsMap::const_iterator it = settings.begin();
884 it != settings.end();
885 ++it) {
886 settings_ir.AddSetting(
887 it->first,
888 (it->second.first & SETTINGS_FLAG_PLEASE_PERSIST) != 0,
889 (it->second.first & SETTINGS_FLAG_PERSISTED) != 0,
890 it->second.second);
892 return CreateFramer(false)->SerializeFrame(settings_ir);
895 SpdyFrame* SpdyTestUtil::ConstructSpdySettingsAck() const {
896 char kEmptyWrite[] = "";
898 if (spdy_version() > SPDY3) {
899 SpdySettingsIR settings_ir;
900 settings_ir.set_is_ack(true);
901 return CreateFramer(false)->SerializeFrame(settings_ir);
903 // No settings ACK write occurs. Create an empty placeholder write.
904 return new SpdyFrame(kEmptyWrite, 0, false);
907 SpdyFrame* SpdyTestUtil::ConstructSpdyPing(uint32 ping_id, bool is_ack) const {
908 SpdyPingIR ping_ir(ping_id);
909 ping_ir.set_is_ack(is_ack);
910 return CreateFramer(false)->SerializeFrame(ping_ir);
913 SpdyFrame* SpdyTestUtil::ConstructSpdyGoAway() const {
914 return ConstructSpdyGoAway(0);
917 SpdyFrame* SpdyTestUtil::ConstructSpdyGoAway(
918 SpdyStreamId last_good_stream_id) const {
919 SpdyGoAwayIR go_ir(last_good_stream_id, GOAWAY_OK, "go away");
920 return CreateFramer(false)->SerializeFrame(go_ir);
923 SpdyFrame* SpdyTestUtil::ConstructSpdyGoAway(SpdyStreamId last_good_stream_id,
924 SpdyGoAwayStatus status,
925 const std::string& desc) const {
926 SpdyGoAwayIR go_ir(last_good_stream_id, status, desc);
927 return CreateFramer(false)->SerializeFrame(go_ir);
930 SpdyFrame* SpdyTestUtil::ConstructSpdyWindowUpdate(
931 const SpdyStreamId stream_id, uint32 delta_window_size) const {
932 SpdyWindowUpdateIR update_ir(stream_id, delta_window_size);
933 return CreateFramer(false)->SerializeFrame(update_ir);
936 // TODO(jgraettinger): Eliminate uses of this method in tests (prefer
937 // SpdyRstStreamIR).
938 SpdyFrame* SpdyTestUtil::ConstructSpdyRstStream(
939 SpdyStreamId stream_id,
940 SpdyRstStreamStatus status) const {
941 SpdyRstStreamIR rst_ir(stream_id, status, "");
942 return CreateFramer(false)->SerializeRstStream(rst_ir);
945 SpdyFrame* SpdyTestUtil::ConstructSpdyGet(
946 const char* const url,
947 bool compressed,
948 SpdyStreamId stream_id,
949 RequestPriority request_priority) const {
950 scoped_ptr<SpdyHeaderBlock> block(ConstructGetHeaderBlock(url));
951 return ConstructSpdySyn(
952 stream_id, *block, request_priority, compressed, true);
955 SpdyFrame* SpdyTestUtil::ConstructSpdyGet(const char* const extra_headers[],
956 int extra_header_count,
957 bool compressed,
958 int stream_id,
959 RequestPriority request_priority,
960 bool direct) const {
961 SpdyHeaderBlock block;
962 AddUrlToHeaderBlock(default_url_.spec(), &block);
963 block[GetMethodKey()] = "GET";
964 MaybeAddVersionHeader(&block);
965 AppendToHeaderBlock(extra_headers, extra_header_count, &block);
966 return ConstructSpdySyn(stream_id, block, request_priority, compressed, true);
969 SpdyFrame* SpdyTestUtil::ConstructSpdyConnect(
970 const char* const extra_headers[],
971 int extra_header_count,
972 int stream_id,
973 RequestPriority priority,
974 const HostPortPair& host_port_pair) const {
975 SpdyHeaderBlock block;
976 block[GetMethodKey()] = "CONNECT";
977 if (spdy_version() < HTTP2) {
978 block[GetPathKey()] = host_port_pair.ToString();
979 block[GetHostKey()] = (host_port_pair.port() == 443)
980 ? host_port_pair.host()
981 : host_port_pair.ToString();
982 } else {
983 block[GetHostKey()] = host_port_pair.ToString();
986 MaybeAddVersionHeader(&block);
987 AppendToHeaderBlock(extra_headers, extra_header_count, &block);
988 return ConstructSpdySyn(stream_id, block, priority, false, false);
991 SpdyFrame* SpdyTestUtil::ConstructSpdyPush(const char* const extra_headers[],
992 int extra_header_count,
993 int stream_id,
994 int associated_stream_id,
995 const char* url) {
996 if (spdy_version() < HTTP2) {
997 SpdySynStreamIR syn_stream(stream_id);
998 syn_stream.set_associated_to_stream_id(associated_stream_id);
999 syn_stream.SetHeader("hello", "bye");
1000 syn_stream.SetHeader(GetStatusKey(), "200 OK");
1001 syn_stream.SetHeader(GetVersionKey(), "HTTP/1.1");
1002 AddUrlToHeaderBlock(url, syn_stream.mutable_header_block());
1003 AppendToHeaderBlock(extra_headers, extra_header_count,
1004 syn_stream.mutable_header_block());
1005 return CreateFramer(false)->SerializeFrame(syn_stream);
1006 } else {
1007 SpdyPushPromiseIR push_promise(associated_stream_id, stream_id);
1008 AddUrlToHeaderBlock(url, push_promise.mutable_header_block());
1009 scoped_ptr<SpdyFrame> push_promise_frame(
1010 CreateFramer(false)->SerializeFrame(push_promise));
1012 SpdyHeadersIR headers(stream_id);
1013 headers.SetHeader("hello", "bye");
1014 headers.SetHeader(GetStatusKey(), "200 OK");
1015 AppendToHeaderBlock(extra_headers, extra_header_count,
1016 headers.mutable_header_block());
1017 scoped_ptr<SpdyFrame> headers_frame(
1018 CreateFramer(false)->SerializeFrame(headers));
1020 int joint_data_size = push_promise_frame->size() + headers_frame->size();
1021 scoped_ptr<char[]> data(new char[joint_data_size]);
1022 const SpdyFrame* frames[2] = {
1023 push_promise_frame.get(), headers_frame.get(),
1025 int combined_size =
1026 CombineFrames(frames, arraysize(frames), data.get(), joint_data_size);
1027 DCHECK_EQ(combined_size, joint_data_size);
1028 return new SpdyFrame(data.release(), joint_data_size, true);
1032 SpdyFrame* SpdyTestUtil::ConstructSpdyPush(const char* const extra_headers[],
1033 int extra_header_count,
1034 int stream_id,
1035 int associated_stream_id,
1036 const char* url,
1037 const char* status,
1038 const char* location) {
1039 if (spdy_version() < HTTP2) {
1040 SpdySynStreamIR syn_stream(stream_id);
1041 syn_stream.set_associated_to_stream_id(associated_stream_id);
1042 syn_stream.SetHeader("hello", "bye");
1043 syn_stream.SetHeader(GetStatusKey(), status);
1044 syn_stream.SetHeader(GetVersionKey(), "HTTP/1.1");
1045 syn_stream.SetHeader("location", location);
1046 AddUrlToHeaderBlock(url, syn_stream.mutable_header_block());
1047 AppendToHeaderBlock(extra_headers, extra_header_count,
1048 syn_stream.mutable_header_block());
1049 return CreateFramer(false)->SerializeFrame(syn_stream);
1050 } else {
1051 SpdyPushPromiseIR push_promise(associated_stream_id, stream_id);
1052 AddUrlToHeaderBlock(url, push_promise.mutable_header_block());
1053 scoped_ptr<SpdyFrame> push_promise_frame(
1054 CreateFramer(false)->SerializeFrame(push_promise));
1056 SpdyHeadersIR headers(stream_id);
1057 headers.SetHeader("hello", "bye");
1058 headers.SetHeader(GetStatusKey(), status);
1059 headers.SetHeader("location", location);
1060 AppendToHeaderBlock(extra_headers, extra_header_count,
1061 headers.mutable_header_block());
1062 scoped_ptr<SpdyFrame> headers_frame(
1063 CreateFramer(false)->SerializeFrame(headers));
1065 int joint_data_size = push_promise_frame->size() + headers_frame->size();
1066 scoped_ptr<char[]> data(new char[joint_data_size]);
1067 const SpdyFrame* frames[2] = {
1068 push_promise_frame.get(), headers_frame.get(),
1070 int combined_size =
1071 CombineFrames(frames, arraysize(frames), data.get(), joint_data_size);
1072 DCHECK_EQ(combined_size, joint_data_size);
1073 return new SpdyFrame(data.release(), joint_data_size, true);
1077 SpdyFrame* SpdyTestUtil::ConstructInitialSpdyPushFrame(
1078 scoped_ptr<SpdyHeaderBlock> headers,
1079 int stream_id,
1080 int associated_stream_id) {
1081 if (spdy_version() < HTTP2) {
1082 SpdySynStreamIR syn_stream(stream_id);
1083 syn_stream.set_associated_to_stream_id(associated_stream_id);
1084 SetPriority(LOWEST, &syn_stream);
1085 syn_stream.set_header_block(*headers);
1086 return CreateFramer(false)->SerializeFrame(syn_stream);
1087 } else {
1088 SpdyPushPromiseIR push_promise(associated_stream_id, stream_id);
1089 push_promise.set_header_block(*headers);
1090 return CreateFramer(false)->SerializeFrame(push_promise);
1094 SpdyFrame* SpdyTestUtil::ConstructSpdyPushHeaders(
1095 int stream_id,
1096 const char* const extra_headers[],
1097 int extra_header_count) {
1098 SpdyHeadersIR headers(stream_id);
1099 headers.SetHeader(GetStatusKey(), "200 OK");
1100 MaybeAddVersionHeader(&headers);
1101 AppendToHeaderBlock(extra_headers, extra_header_count,
1102 headers.mutable_header_block());
1103 return CreateFramer(false)->SerializeFrame(headers);
1106 SpdyFrame* SpdyTestUtil::ConstructSpdyHeaderFrame(int stream_id,
1107 const char* const headers[],
1108 int header_count) {
1109 SpdyHeadersIR spdy_headers(stream_id);
1110 AppendToHeaderBlock(headers, header_count,
1111 spdy_headers.mutable_header_block());
1112 return CreateFramer(false)->SerializeFrame(spdy_headers);
1115 SpdyFrame* SpdyTestUtil::ConstructSpdySyn(int stream_id,
1116 const SpdyHeaderBlock& block,
1117 RequestPriority priority,
1118 bool compressed,
1119 bool fin) const {
1120 if (protocol_ < kProtoHTTP2) {
1121 SpdySynStreamIR syn_stream(stream_id);
1122 syn_stream.set_header_block(block);
1123 syn_stream.set_priority(
1124 ConvertRequestPriorityToSpdyPriority(priority, spdy_version()));
1125 syn_stream.set_fin(fin);
1126 return CreateFramer(compressed)->SerializeFrame(syn_stream);
1127 } else {
1128 SpdyHeadersIR headers(stream_id);
1129 headers.set_header_block(block);
1130 headers.set_has_priority(true);
1131 headers.set_priority(
1132 ConvertRequestPriorityToSpdyPriority(priority, spdy_version()));
1133 headers.set_fin(fin);
1134 return CreateFramer(compressed)->SerializeFrame(headers);
1138 SpdyFrame* SpdyTestUtil::ConstructSpdyReply(int stream_id,
1139 const SpdyHeaderBlock& headers) {
1140 if (protocol_ < kProtoHTTP2) {
1141 SpdySynReplyIR syn_reply(stream_id);
1142 syn_reply.set_header_block(headers);
1143 return CreateFramer(false)->SerializeFrame(syn_reply);
1144 } else {
1145 SpdyHeadersIR reply(stream_id);
1146 reply.set_header_block(headers);
1147 return CreateFramer(false)->SerializeFrame(reply);
1151 SpdyFrame* SpdyTestUtil::ConstructSpdySynReplyError(
1152 const char* const status,
1153 const char* const* const extra_headers,
1154 int extra_header_count,
1155 int stream_id) {
1156 SpdyHeaderBlock block;
1157 block["hello"] = "bye";
1158 block[GetStatusKey()] = status;
1159 MaybeAddVersionHeader(&block);
1160 AppendToHeaderBlock(extra_headers, extra_header_count, &block);
1162 return ConstructSpdyReply(stream_id, block);
1165 SpdyFrame* SpdyTestUtil::ConstructSpdyGetSynReplyRedirect(int stream_id) {
1166 static const char* const kExtraHeaders[] = {
1167 "location", "http://www.foo.com/index.php",
1169 return ConstructSpdySynReplyError("301 Moved Permanently", kExtraHeaders,
1170 arraysize(kExtraHeaders)/2, stream_id);
1173 SpdyFrame* SpdyTestUtil::ConstructSpdySynReplyError(int stream_id) {
1174 return ConstructSpdySynReplyError("500 Internal Server Error", NULL, 0, 1);
1177 SpdyFrame* SpdyTestUtil::ConstructSpdyGetSynReply(
1178 const char* const extra_headers[],
1179 int extra_header_count,
1180 int stream_id) {
1181 SpdyHeaderBlock block;
1182 block["hello"] = "bye";
1183 block[GetStatusKey()] = "200";
1184 MaybeAddVersionHeader(&block);
1185 AppendToHeaderBlock(extra_headers, extra_header_count, &block);
1187 return ConstructSpdyReply(stream_id, block);
1190 SpdyFrame* SpdyTestUtil::ConstructSpdyPost(const char* url,
1191 SpdyStreamId stream_id,
1192 int64 content_length,
1193 RequestPriority priority,
1194 const char* const extra_headers[],
1195 int extra_header_count) {
1196 scoped_ptr<SpdyHeaderBlock> block(
1197 ConstructPostHeaderBlock(url, content_length));
1198 AppendToHeaderBlock(extra_headers, extra_header_count, block.get());
1199 return ConstructSpdySyn(stream_id, *block, priority, false, false);
1202 SpdyFrame* SpdyTestUtil::ConstructChunkedSpdyPost(
1203 const char* const extra_headers[],
1204 int extra_header_count) {
1205 SpdyHeaderBlock block;
1206 block[GetMethodKey()] = "POST";
1207 AddUrlToHeaderBlock(default_url_.spec(), &block);
1208 MaybeAddVersionHeader(&block);
1209 AppendToHeaderBlock(extra_headers, extra_header_count, &block);
1210 return ConstructSpdySyn(1, block, LOWEST, false, false);
1213 SpdyFrame* SpdyTestUtil::ConstructSpdyPostSynReply(
1214 const char* const extra_headers[],
1215 int extra_header_count) {
1216 // TODO(jgraettinger): Remove this method.
1217 return ConstructSpdyGetSynReply(NULL, 0, 1);
1220 SpdyFrame* SpdyTestUtil::ConstructSpdyBodyFrame(int stream_id, bool fin) {
1221 SpdyFramer framer(spdy_version_);
1222 SpdyDataIR data_ir(stream_id,
1223 base::StringPiece(kUploadData, kUploadDataSize));
1224 data_ir.set_fin(fin);
1225 return framer.SerializeData(data_ir);
1228 SpdyFrame* SpdyTestUtil::ConstructSpdyBodyFrame(int stream_id,
1229 const char* data,
1230 uint32 len,
1231 bool fin) {
1232 SpdyFramer framer(spdy_version_);
1233 SpdyDataIR data_ir(stream_id, base::StringPiece(data, len));
1234 data_ir.set_fin(fin);
1235 return framer.SerializeData(data_ir);
1238 SpdyFrame* SpdyTestUtil::ConstructSpdyBodyFrame(int stream_id,
1239 const char* data,
1240 uint32 len,
1241 bool fin,
1242 int padding_length) {
1243 SpdyFramer framer(spdy_version_);
1244 SpdyDataIR data_ir(stream_id, base::StringPiece(data, len));
1245 data_ir.set_fin(fin);
1246 data_ir.set_padding_len(padding_length);
1247 return framer.SerializeData(data_ir);
1250 SpdyFrame* SpdyTestUtil::ConstructWrappedSpdyFrame(
1251 const scoped_ptr<SpdyFrame>& frame,
1252 int stream_id) {
1253 return ConstructSpdyBodyFrame(stream_id, frame->data(),
1254 frame->size(), false);
1257 const SpdyHeaderInfo SpdyTestUtil::MakeSpdyHeader(SpdyFrameType type) {
1258 const SpdyHeaderInfo kHeader = {
1259 type,
1260 1, // Stream ID
1261 0, // Associated stream ID
1262 ConvertRequestPriorityToSpdyPriority(LOWEST, spdy_version_),
1263 kSpdyCredentialSlotUnused,
1264 CONTROL_FLAG_FIN, // Control Flags
1265 false, // Compressed
1266 RST_STREAM_INVALID,
1267 NULL, // Data
1268 0, // Length
1269 DATA_FLAG_NONE
1271 return kHeader;
1274 scoped_ptr<SpdyFramer> SpdyTestUtil::CreateFramer(bool compressed) const {
1275 scoped_ptr<SpdyFramer> framer(new SpdyFramer(spdy_version_));
1276 framer->set_enable_compression(compressed);
1277 return framer.Pass();
1280 const char* SpdyTestUtil::GetMethodKey() const {
1281 return ":method";
1284 const char* SpdyTestUtil::GetStatusKey() const {
1285 return ":status";
1288 const char* SpdyTestUtil::GetHostKey() const {
1289 if (protocol_ < kProtoHTTP2)
1290 return ":host";
1291 else
1292 return ":authority";
1295 const char* SpdyTestUtil::GetSchemeKey() const {
1296 return ":scheme";
1299 const char* SpdyTestUtil::GetVersionKey() const {
1300 return ":version";
1303 const char* SpdyTestUtil::GetPathKey() const {
1304 return ":path";
1307 scoped_ptr<SpdyHeaderBlock> SpdyTestUtil::ConstructHeaderBlock(
1308 base::StringPiece method,
1309 base::StringPiece url,
1310 int64* content_length) const {
1311 std::string scheme, host, path;
1312 ParseUrl(url.data(), &scheme, &host, &path);
1313 scoped_ptr<SpdyHeaderBlock> headers(new SpdyHeaderBlock());
1314 (*headers)[GetMethodKey()] = method.as_string();
1315 (*headers)[GetPathKey()] = path.c_str();
1316 (*headers)[GetHostKey()] = host.c_str();
1317 (*headers)[GetSchemeKey()] = scheme.c_str();
1318 if (include_version_header()) {
1319 (*headers)[GetVersionKey()] = "HTTP/1.1";
1321 if (content_length) {
1322 std::string length_str = base::Int64ToString(*content_length);
1323 (*headers)["content-length"] = length_str;
1325 return headers.Pass();
1328 void SpdyTestUtil::MaybeAddVersionHeader(
1329 SpdyFrameWithHeaderBlockIR* frame_ir) const {
1330 if (include_version_header()) {
1331 frame_ir->SetHeader(GetVersionKey(), "HTTP/1.1");
1335 void SpdyTestUtil::MaybeAddVersionHeader(SpdyHeaderBlock* block) const {
1336 if (include_version_header()) {
1337 (*block)[GetVersionKey()] = "HTTP/1.1";
1341 void SpdyTestUtil::SetPriority(RequestPriority priority,
1342 SpdySynStreamIR* ir) const {
1343 ir->set_priority(ConvertRequestPriorityToSpdyPriority(
1344 priority, spdy_version()));
1347 } // namespace net