1 // Copyright (c) 2012 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/quic/quic_stream_factory.h"
7 #include "base/run_loop.h"
8 #include "base/strings/string_util.h"
9 #include "net/base/test_data_directory.h"
10 #include "net/cert/cert_verifier.h"
11 #include "net/dns/mock_host_resolver.h"
12 #include "net/http/http_response_headers.h"
13 #include "net/http/http_response_info.h"
14 #include "net/http/http_util.h"
15 #include "net/quic/crypto/crypto_handshake.h"
16 #include "net/quic/crypto/proof_verifier_chromium.h"
17 #include "net/quic/crypto/quic_decrypter.h"
18 #include "net/quic/crypto/quic_encrypter.h"
19 #include "net/quic/quic_http_stream.h"
20 #include "net/quic/quic_server_id.h"
21 #include "net/quic/test_tools/mock_clock.h"
22 #include "net/quic/test_tools/mock_crypto_client_stream_factory.h"
23 #include "net/quic/test_tools/mock_random.h"
24 #include "net/quic/test_tools/quic_test_packet_maker.h"
25 #include "net/quic/test_tools/quic_test_utils.h"
26 #include "net/socket/socket_test_util.h"
27 #include "net/ssl/channel_id_service.h"
28 #include "net/ssl/default_channel_id_store.h"
29 #include "net/test/cert_test_util.h"
30 #include "testing/gtest/include/gtest/gtest.h"
32 using base::StringPiece
;
40 const char kDefaultServerHostName
[] = "www.google.com";
41 const int kDefaultServerPort
= 443;
42 } // namespace anonymous
44 class QuicStreamFactoryPeer
{
46 static QuicCryptoClientConfig
* GetCryptoConfig(QuicStreamFactory
* factory
) {
47 return &factory
->crypto_config_
;
50 static bool HasActiveSession(QuicStreamFactory
* factory
,
51 const HostPortPair
& host_port_pair
,
53 QuicServerId
server_id(host_port_pair
, is_https
, PRIVACY_MODE_DISABLED
);
54 return factory
->HasActiveSession(server_id
);
57 static QuicClientSession
* GetActiveSession(
58 QuicStreamFactory
* factory
,
59 const HostPortPair
& host_port_pair
,
61 QuicServerId
server_id(host_port_pair
, is_https
, PRIVACY_MODE_DISABLED
);
62 DCHECK(factory
->HasActiveSession(server_id
));
63 return factory
->active_sessions_
[server_id
];
66 static scoped_ptr
<QuicHttpStream
> CreateIfSessionExists(
67 QuicStreamFactory
* factory
,
68 const HostPortPair
& host_port_pair
,
70 const BoundNetLog
& net_log
) {
71 QuicServerId
server_id(host_port_pair
, is_https
, PRIVACY_MODE_DISABLED
);
72 return factory
->CreateIfSessionExists(server_id
, net_log
);
75 static bool IsLiveSession(QuicStreamFactory
* factory
,
76 QuicClientSession
* session
) {
77 for (QuicStreamFactory::SessionIdMap::iterator it
=
78 factory
->all_sessions_
.begin();
79 it
!= factory
->all_sessions_
.end(); ++it
) {
80 if (it
->first
== session
)
87 class QuicStreamFactoryTest
: public ::testing::TestWithParam
<QuicVersion
> {
89 QuicStreamFactoryTest()
90 : random_generator_(0),
91 maker_(GetParam(), 0),
92 clock_(new MockClock()),
93 cert_verifier_(CertVerifier::CreateDefault()),
94 channel_id_service_(new ChannelIDService(
95 new DefaultChannelIDStore(NULL
),
96 base::MessageLoopProxy::current())),
97 factory_(&host_resolver_
, &socket_factory_
,
98 base::WeakPtr
<HttpServerProperties
>(), cert_verifier_
.get(),
99 channel_id_service_
.get(),
100 &crypto_client_stream_factory_
, &random_generator_
, clock_
,
101 kDefaultMaxPacketSize
, std::string(),
102 SupportedVersions(GetParam()), true, true, true,
104 host_port_pair_(kDefaultServerHostName
, kDefaultServerPort
),
106 privacy_mode_(PRIVACY_MODE_DISABLED
) {
107 factory_
.set_require_confirmation(false);
110 scoped_ptr
<QuicHttpStream
> CreateIfSessionExists(
111 const HostPortPair
& host_port_pair
,
112 const BoundNetLog
& net_log
) {
113 return QuicStreamFactoryPeer::CreateIfSessionExists(
114 &factory_
, host_port_pair
, false, net_log_
);
117 int GetSourcePortForNewSession(const HostPortPair
& destination
) {
118 return GetSourcePortForNewSessionInner(destination
, false);
121 int GetSourcePortForNewSessionAndGoAway(
122 const HostPortPair
& destination
) {
123 return GetSourcePortForNewSessionInner(destination
, true);
126 int GetSourcePortForNewSessionInner(const HostPortPair
& destination
,
127 bool goaway_received
) {
128 // Should only be called if there is no active session for this destination.
129 EXPECT_EQ(NULL
, CreateIfSessionExists(destination
, net_log_
).get());
130 size_t socket_count
= socket_factory_
.udp_client_sockets().size();
133 MockRead(ASYNC
, OK
, 0) // EOF
135 DeterministicSocketData
socket_data(reads
, arraysize(reads
), NULL
, 0);
136 socket_data
.StopAfter(1);
137 socket_factory_
.AddSocketDataProvider(&socket_data
);
139 QuicStreamRequest
request(&factory_
);
140 EXPECT_EQ(ERR_IO_PENDING
,
141 request
.Request(destination
,
146 callback_
.callback()));
148 EXPECT_EQ(OK
, callback_
.WaitForResult());
149 scoped_ptr
<QuicHttpStream
> stream
= request
.ReleaseStream();
150 EXPECT_TRUE(stream
.get());
153 QuicClientSession
* session
= QuicStreamFactoryPeer::GetActiveSession(
154 &factory_
, destination
, is_https_
);
156 if (socket_count
+ 1 != socket_factory_
.udp_client_sockets().size()) {
163 udp_client_sockets()[socket_count
]->GetLocalAddress(&endpoint
);
164 int port
= endpoint
.port();
165 if (goaway_received
) {
166 QuicGoAwayFrame
goaway(QUIC_NO_ERROR
, 1, "");
167 session
->OnGoAway(goaway
);
170 factory_
.OnSessionClosed(session
);
171 EXPECT_EQ(NULL
, CreateIfSessionExists(destination
, net_log_
).get());
172 EXPECT_TRUE(socket_data
.at_read_eof());
173 EXPECT_TRUE(socket_data
.at_write_eof());
177 scoped_ptr
<QuicEncryptedPacket
> ConstructRstPacket() {
178 QuicStreamId stream_id
= kClientDataStreamId1
;
179 return maker_
.MakeRstPacket(
181 AdjustErrorForVersion(QUIC_RST_FLOW_CONTROL_ACCOUNTING
, GetParam()));
184 MockHostResolver host_resolver_
;
185 DeterministicMockClientSocketFactory socket_factory_
;
186 MockCryptoClientStreamFactory crypto_client_stream_factory_
;
187 MockRandom random_generator_
;
188 QuicTestPacketMaker maker_
;
189 MockClock
* clock_
; // Owned by factory_.
190 scoped_ptr
<CertVerifier
> cert_verifier_
;
191 scoped_ptr
<ChannelIDService
> channel_id_service_
;
192 QuicStreamFactory factory_
;
193 HostPortPair host_port_pair_
;
195 PrivacyMode privacy_mode_
;
196 BoundNetLog net_log_
;
197 TestCompletionCallback callback_
;
200 INSTANTIATE_TEST_CASE_P(Version
, QuicStreamFactoryTest
,
201 ::testing::ValuesIn(QuicSupportedVersions()));
203 TEST_P(QuicStreamFactoryTest
, CreateIfSessionExists
) {
204 EXPECT_EQ(NULL
, CreateIfSessionExists(host_port_pair_
, net_log_
).get());
207 TEST_P(QuicStreamFactoryTest
, Create
) {
209 MockRead(ASYNC
, OK
, 0) // EOF
211 DeterministicSocketData
socket_data(reads
, arraysize(reads
), NULL
, 0);
212 socket_factory_
.AddSocketDataProvider(&socket_data
);
213 socket_data
.StopAfter(1);
215 QuicStreamRequest
request(&factory_
);
216 EXPECT_EQ(ERR_IO_PENDING
,
217 request
.Request(host_port_pair_
,
222 callback_
.callback()));
224 EXPECT_EQ(OK
, callback_
.WaitForResult());
225 scoped_ptr
<QuicHttpStream
> stream
= request
.ReleaseStream();
226 EXPECT_TRUE(stream
.get());
228 // Will reset stream 3.
229 stream
= CreateIfSessionExists(host_port_pair_
, net_log_
);
230 EXPECT_TRUE(stream
.get());
232 // TODO(rtenneti): We should probably have a tests that HTTP and HTTPS result
233 // in streams on different sessions.
234 QuicStreamRequest
request2(&factory_
);
236 request2
.Request(host_port_pair_
,
241 callback_
.callback()));
242 stream
= request2
.ReleaseStream(); // Will reset stream 5.
243 stream
.reset(); // Will reset stream 7.
245 EXPECT_TRUE(socket_data
.at_read_eof());
246 EXPECT_TRUE(socket_data
.at_write_eof());
249 TEST_P(QuicStreamFactoryTest
, CreateZeroRtt
) {
251 MockRead(ASYNC
, OK
, 0) // EOF
253 DeterministicSocketData
socket_data(reads
, arraysize(reads
), NULL
, 0);
254 socket_factory_
.AddSocketDataProvider(&socket_data
);
255 socket_data
.StopAfter(1);
257 crypto_client_stream_factory_
.set_handshake_mode(
258 MockCryptoClientStream::ZERO_RTT
);
259 host_resolver_
.set_synchronous_mode(true);
260 host_resolver_
.rules()->AddIPLiteralRule(host_port_pair_
.host(),
263 QuicStreamRequest
request(&factory_
);
265 request
.Request(host_port_pair_
,
270 callback_
.callback()));
272 scoped_ptr
<QuicHttpStream
> stream
= request
.ReleaseStream();
273 EXPECT_TRUE(stream
.get());
274 EXPECT_TRUE(socket_data
.at_read_eof());
275 EXPECT_TRUE(socket_data
.at_write_eof());
278 TEST_P(QuicStreamFactoryTest
, CreateZeroRttPost
) {
280 MockRead(ASYNC
, OK
, 0) // EOF
282 DeterministicSocketData
socket_data(reads
, arraysize(reads
), NULL
, 0);
283 socket_factory_
.AddSocketDataProvider(&socket_data
);
284 socket_data
.StopAfter(1);
286 crypto_client_stream_factory_
.set_handshake_mode(
287 MockCryptoClientStream::ZERO_RTT
);
288 host_resolver_
.set_synchronous_mode(true);
289 host_resolver_
.rules()->AddIPLiteralRule(host_port_pair_
.host(),
292 QuicStreamRequest
request(&factory_
);
293 // Posts require handshake confirmation, so this will return asynchronously.
294 EXPECT_EQ(ERR_IO_PENDING
,
295 request
.Request(host_port_pair_
,
300 callback_
.callback()));
302 // Confirm the handshake and verify that the stream is created.
303 crypto_client_stream_factory_
.last_stream()->SendOnCryptoHandshakeEvent(
304 QuicSession::HANDSHAKE_CONFIRMED
);
306 EXPECT_EQ(OK
, callback_
.WaitForResult());
307 scoped_ptr
<QuicHttpStream
> stream
= request
.ReleaseStream();
308 EXPECT_TRUE(stream
.get());
309 EXPECT_TRUE(socket_data
.at_read_eof());
310 EXPECT_TRUE(socket_data
.at_write_eof());
313 TEST_P(QuicStreamFactoryTest
, CreateHttpVsHttps
) {
315 MockRead(ASYNC
, OK
, 0) // EOF
317 DeterministicSocketData
socket_data1(reads
, arraysize(reads
), NULL
, 0);
318 DeterministicSocketData
socket_data2(reads
, arraysize(reads
), NULL
, 0);
319 socket_factory_
.AddSocketDataProvider(&socket_data1
);
320 socket_factory_
.AddSocketDataProvider(&socket_data2
);
321 socket_data1
.StopAfter(1);
322 socket_data2
.StopAfter(1);
324 QuicStreamRequest
request(&factory_
);
325 EXPECT_EQ(ERR_IO_PENDING
,
326 request
.Request(host_port_pair_
,
331 callback_
.callback()));
333 EXPECT_EQ(OK
, callback_
.WaitForResult());
334 scoped_ptr
<QuicHttpStream
> stream
= request
.ReleaseStream();
335 EXPECT_TRUE(stream
.get());
337 QuicStreamRequest
request2(&factory_
);
338 EXPECT_EQ(ERR_IO_PENDING
,
339 request2
.Request(host_port_pair_
,
344 callback_
.callback()));
345 EXPECT_EQ(OK
, callback_
.WaitForResult());
346 stream
= request2
.ReleaseStream();
347 EXPECT_TRUE(stream
.get());
350 EXPECT_NE(QuicStreamFactoryPeer::GetActiveSession(
351 &factory_
, host_port_pair_
, is_https_
),
352 QuicStreamFactoryPeer::GetActiveSession(
353 &factory_
, host_port_pair_
, !is_https_
));
355 EXPECT_TRUE(socket_data1
.at_read_eof());
356 EXPECT_TRUE(socket_data1
.at_write_eof());
357 EXPECT_TRUE(socket_data2
.at_read_eof());
358 EXPECT_TRUE(socket_data2
.at_write_eof());
361 // TODO(rch): re-enable this.
362 TEST_P(QuicStreamFactoryTest
, DISABLED_Pooling
) {
364 MockRead(ASYNC
, OK
, 0) // EOF
366 DeterministicSocketData
socket_data(reads
, arraysize(reads
), NULL
, 0);
367 socket_factory_
.AddSocketDataProvider(&socket_data
);
368 socket_data
.StopAfter(1);
370 HostPortPair
server2("mail.google.com", kDefaultServerPort
);
371 host_resolver_
.set_synchronous_mode(true);
372 host_resolver_
.rules()->AddIPLiteralRule(
373 kDefaultServerHostName
, "192.168.0.1", "");
374 host_resolver_
.rules()->AddIPLiteralRule(
375 "mail.google.com", "192.168.0.1", "");
377 QuicStreamRequest
request(&factory_
);
379 request
.Request(host_port_pair_
,
384 callback_
.callback()));
385 scoped_ptr
<QuicHttpStream
> stream
= request
.ReleaseStream();
386 EXPECT_TRUE(stream
.get());
388 TestCompletionCallback callback
;
389 QuicStreamRequest
request2(&factory_
);
391 request2
.Request(server2
,
396 callback
.callback()));
397 scoped_ptr
<QuicHttpStream
> stream2
= request2
.ReleaseStream();
398 EXPECT_TRUE(stream2
.get());
401 QuicStreamFactoryPeer::GetActiveSession(
402 &factory_
, host_port_pair_
, is_https_
),
403 QuicStreamFactoryPeer::GetActiveSession(&factory_
, server2
, is_https_
));
405 EXPECT_TRUE(socket_data
.at_read_eof());
406 EXPECT_TRUE(socket_data
.at_write_eof());
409 TEST_P(QuicStreamFactoryTest
, NoPoolingAfterGoAway
) {
411 MockRead(ASYNC
, OK
, 0) // EOF
413 DeterministicSocketData
socket_data1(reads
, arraysize(reads
), NULL
, 0);
414 DeterministicSocketData
socket_data2(reads
, arraysize(reads
), NULL
, 0);
415 socket_factory_
.AddSocketDataProvider(&socket_data1
);
416 socket_factory_
.AddSocketDataProvider(&socket_data2
);
417 socket_data1
.StopAfter(1);
418 socket_data2
.StopAfter(1);
420 HostPortPair
server2("mail.google.com", kDefaultServerPort
);
421 host_resolver_
.set_synchronous_mode(true);
422 host_resolver_
.rules()->AddIPLiteralRule(
423 kDefaultServerHostName
, "192.168.0.1", "");
424 host_resolver_
.rules()->AddIPLiteralRule(
425 "mail.google.com", "192.168.0.1", "");
427 QuicStreamRequest
request(&factory_
);
429 request
.Request(host_port_pair_
,
434 callback_
.callback()));
435 scoped_ptr
<QuicHttpStream
> stream
= request
.ReleaseStream();
436 EXPECT_TRUE(stream
.get());
438 TestCompletionCallback callback
;
439 QuicStreamRequest
request2(&factory_
);
441 request2
.Request(server2
,
446 callback
.callback()));
447 scoped_ptr
<QuicHttpStream
> stream2
= request2
.ReleaseStream();
448 EXPECT_TRUE(stream2
.get());
450 factory_
.OnSessionGoingAway(QuicStreamFactoryPeer::GetActiveSession(
451 &factory_
, host_port_pair_
, is_https_
));
452 EXPECT_FALSE(QuicStreamFactoryPeer::HasActiveSession(
453 &factory_
, host_port_pair_
, is_https_
));
454 EXPECT_FALSE(QuicStreamFactoryPeer::HasActiveSession(
455 &factory_
, server2
, is_https_
));
457 TestCompletionCallback callback3
;
458 QuicStreamRequest
request3(&factory_
);
460 request3
.Request(server2
,
465 callback3
.callback()));
466 scoped_ptr
<QuicHttpStream
> stream3
= request3
.ReleaseStream();
467 EXPECT_TRUE(stream3
.get());
469 EXPECT_TRUE(QuicStreamFactoryPeer::HasActiveSession(
470 &factory_
, server2
, is_https_
));
472 EXPECT_TRUE(socket_data1
.at_read_eof());
473 EXPECT_TRUE(socket_data1
.at_write_eof());
474 EXPECT_TRUE(socket_data2
.at_read_eof());
475 EXPECT_TRUE(socket_data2
.at_write_eof());
478 // TODO(rch): re-enable this.
479 TEST_P(QuicStreamFactoryTest
, DISABLED_HttpsPooling
) {
481 MockRead(ASYNC
, OK
, 0) // EOF
483 DeterministicSocketData
socket_data(reads
, arraysize(reads
), NULL
, 0);
484 socket_factory_
.AddSocketDataProvider(&socket_data
);
485 socket_data
.StopAfter(1);
487 HostPortPair
server1("www.example.org", 443);
488 HostPortPair
server2("mail.example.org", 443);
490 // Load a cert that is valid for:
491 // www.example.org (server1)
492 // mail.example.org (server2)
494 base::FilePath certs_dir
= GetTestCertsDirectory();
495 scoped_refptr
<X509Certificate
> test_cert(
496 ImportCertFromFile(certs_dir
, "spdy_pooling.pem"));
497 ASSERT_NE(static_cast<X509Certificate
*>(NULL
), test_cert
);
498 ProofVerifyDetailsChromium verify_details
;
499 verify_details
.cert_verify_result
.verified_cert
= test_cert
;
500 crypto_client_stream_factory_
.set_proof_verify_details(&verify_details
);
502 host_resolver_
.set_synchronous_mode(true);
503 host_resolver_
.rules()->AddIPLiteralRule(server1
.host(), "192.168.0.1", "");
504 host_resolver_
.rules()->AddIPLiteralRule(server2
.host(), "192.168.0.1", "");
506 QuicStreamRequest
request(&factory_
);
509 request
.Request(server1
,
514 callback_
.callback()));
515 scoped_ptr
<QuicHttpStream
> stream
= request
.ReleaseStream();
516 EXPECT_TRUE(stream
.get());
518 TestCompletionCallback callback
;
519 QuicStreamRequest
request2(&factory_
);
521 request2
.Request(server2
,
526 callback_
.callback()));
527 scoped_ptr
<QuicHttpStream
> stream2
= request2
.ReleaseStream();
528 EXPECT_TRUE(stream2
.get());
530 EXPECT_EQ(QuicStreamFactoryPeer::GetActiveSession(
531 &factory_
, server1
, is_https_
),
532 QuicStreamFactoryPeer::GetActiveSession(
533 &factory_
, server2
, is_https_
));
535 EXPECT_TRUE(socket_data
.at_read_eof());
536 EXPECT_TRUE(socket_data
.at_write_eof());
539 TEST_P(QuicStreamFactoryTest
, NoHttpsPoolingWithCertMismatch
) {
541 MockRead(ASYNC
, OK
, 0) // EOF
543 DeterministicSocketData
socket_data1(reads
, arraysize(reads
), NULL
, 0);
544 DeterministicSocketData
socket_data2(reads
, arraysize(reads
), NULL
, 0);
545 socket_factory_
.AddSocketDataProvider(&socket_data1
);
546 socket_factory_
.AddSocketDataProvider(&socket_data2
);
547 socket_data1
.StopAfter(1);
548 socket_data2
.StopAfter(1);
550 HostPortPair
server1("www.example.org", 443);
551 HostPortPair
server2("mail.google.com", 443);
553 // Load a cert that is valid for:
554 // www.example.org (server1)
557 // But is not valid for mail.google.com (server2).
558 base::FilePath certs_dir
= GetTestCertsDirectory();
559 scoped_refptr
<X509Certificate
> test_cert(
560 ImportCertFromFile(certs_dir
, "spdy_pooling.pem"));
561 ASSERT_NE(static_cast<X509Certificate
*>(NULL
), test_cert
);
562 ProofVerifyDetailsChromium verify_details
;
563 verify_details
.cert_verify_result
.verified_cert
= test_cert
;
564 crypto_client_stream_factory_
.set_proof_verify_details(&verify_details
);
567 host_resolver_
.set_synchronous_mode(true);
568 host_resolver_
.rules()->AddIPLiteralRule(server1
.host(), "192.168.0.1", "");
569 host_resolver_
.rules()->AddIPLiteralRule(server2
.host(), "192.168.0.1", "");
571 QuicStreamRequest
request(&factory_
);
574 request
.Request(server1
,
579 callback_
.callback()));
580 scoped_ptr
<QuicHttpStream
> stream
= request
.ReleaseStream();
581 EXPECT_TRUE(stream
.get());
583 TestCompletionCallback callback
;
584 QuicStreamRequest
request2(&factory_
);
586 request2
.Request(server2
,
591 callback_
.callback()));
592 scoped_ptr
<QuicHttpStream
> stream2
= request2
.ReleaseStream();
593 EXPECT_TRUE(stream2
.get());
595 EXPECT_NE(QuicStreamFactoryPeer::GetActiveSession(
596 &factory_
, server1
, is_https_
),
597 QuicStreamFactoryPeer::GetActiveSession(
598 &factory_
, server2
, is_https_
));
600 EXPECT_TRUE(socket_data1
.at_read_eof());
601 EXPECT_TRUE(socket_data1
.at_write_eof());
602 EXPECT_TRUE(socket_data2
.at_read_eof());
603 EXPECT_TRUE(socket_data2
.at_write_eof());
606 TEST_P(QuicStreamFactoryTest
, Goaway
) {
608 MockRead(ASYNC
, OK
, 0) // EOF
610 DeterministicSocketData
socket_data(reads
, arraysize(reads
), NULL
, 0);
611 socket_data
.StopAfter(1);
612 socket_factory_
.AddSocketDataProvider(&socket_data
);
613 DeterministicSocketData
socket_data2(reads
, arraysize(reads
), NULL
, 0);
614 socket_data2
.StopAfter(1);
615 socket_factory_
.AddSocketDataProvider(&socket_data2
);
617 QuicStreamRequest
request(&factory_
);
618 EXPECT_EQ(ERR_IO_PENDING
,
619 request
.Request(host_port_pair_
,
624 callback_
.callback()));
626 EXPECT_EQ(OK
, callback_
.WaitForResult());
627 scoped_ptr
<QuicHttpStream
> stream
= request
.ReleaseStream();
628 EXPECT_TRUE(stream
.get());
630 // Mark the session as going away. Ensure that while it is still alive
631 // that it is no longer active.
632 QuicClientSession
* session
= QuicStreamFactoryPeer::GetActiveSession(
633 &factory_
, host_port_pair_
, is_https_
);
634 factory_
.OnSessionGoingAway(session
);
635 EXPECT_EQ(true, QuicStreamFactoryPeer::IsLiveSession(&factory_
, session
));
636 EXPECT_FALSE(QuicStreamFactoryPeer::HasActiveSession(
637 &factory_
, host_port_pair_
, is_https_
));
638 EXPECT_EQ(NULL
, CreateIfSessionExists(host_port_pair_
, net_log_
).get());
640 // Create a new request for the same destination and verify that a
641 // new session is created.
642 QuicStreamRequest
request2(&factory_
);
643 EXPECT_EQ(ERR_IO_PENDING
,
644 request2
.Request(host_port_pair_
,
649 callback_
.callback()));
650 EXPECT_EQ(OK
, callback_
.WaitForResult());
651 scoped_ptr
<QuicHttpStream
> stream2
= request2
.ReleaseStream();
652 EXPECT_TRUE(stream2
.get());
654 EXPECT_TRUE(QuicStreamFactoryPeer::HasActiveSession(&factory_
,
658 QuicStreamFactoryPeer::GetActiveSession(
659 &factory_
, host_port_pair_
, is_https_
));
660 EXPECT_EQ(true, QuicStreamFactoryPeer::IsLiveSession(&factory_
, session
));
665 EXPECT_TRUE(socket_data
.at_read_eof());
666 EXPECT_TRUE(socket_data
.at_write_eof());
667 EXPECT_TRUE(socket_data2
.at_read_eof());
668 EXPECT_TRUE(socket_data2
.at_write_eof());
671 TEST_P(QuicStreamFactoryTest
, MaxOpenStream
) {
673 MockRead(ASYNC
, OK
, 0) // EOF
675 QuicStreamId stream_id
= kClientDataStreamId1
;
676 scoped_ptr
<QuicEncryptedPacket
> rst(
677 maker_
.MakeRstPacket(1, true, stream_id
, QUIC_STREAM_CANCELLED
));
678 MockWrite writes
[] = {
679 MockWrite(ASYNC
, rst
->data(), rst
->length(), 1),
681 DeterministicSocketData
socket_data(reads
, arraysize(reads
),
682 writes
, arraysize(writes
));
683 socket_factory_
.AddSocketDataProvider(&socket_data
);
684 socket_data
.StopAfter(1);
686 HttpRequestInfo request_info
;
687 std::vector
<QuicHttpStream
*> streams
;
688 // The MockCryptoClientStream sets max_open_streams to be
689 // 2 * kDefaultMaxStreamsPerConnection.
690 for (size_t i
= 0; i
< 2 * kDefaultMaxStreamsPerConnection
; i
++) {
691 QuicStreamRequest
request(&factory_
);
692 int rv
= request
.Request(host_port_pair_
,
697 callback_
.callback());
699 EXPECT_EQ(ERR_IO_PENDING
, rv
);
700 EXPECT_EQ(OK
, callback_
.WaitForResult());
704 scoped_ptr
<QuicHttpStream
> stream
= request
.ReleaseStream();
706 EXPECT_EQ(OK
, stream
->InitializeStream(
707 &request_info
, DEFAULT_PRIORITY
, net_log_
, CompletionCallback()));
708 streams
.push_back(stream
.release());
711 QuicStreamRequest
request(&factory_
);
713 request
.Request(host_port_pair_
,
718 CompletionCallback()));
719 scoped_ptr
<QuicHttpStream
> stream
= request
.ReleaseStream();
721 EXPECT_EQ(ERR_IO_PENDING
, stream
->InitializeStream(
722 &request_info
, DEFAULT_PRIORITY
, net_log_
, callback_
.callback()));
724 // Close the first stream.
725 streams
.front()->Close(false);
727 ASSERT_TRUE(callback_
.have_result());
729 EXPECT_EQ(OK
, callback_
.WaitForResult());
731 EXPECT_TRUE(socket_data
.at_read_eof());
732 EXPECT_TRUE(socket_data
.at_write_eof());
733 STLDeleteElements(&streams
);
736 TEST_P(QuicStreamFactoryTest
, ResolutionErrorInCreate
) {
737 DeterministicSocketData
socket_data(NULL
, 0, NULL
, 0);
738 socket_factory_
.AddSocketDataProvider(&socket_data
);
740 host_resolver_
.rules()->AddSimulatedFailure(kDefaultServerHostName
);
742 QuicStreamRequest
request(&factory_
);
743 EXPECT_EQ(ERR_IO_PENDING
,
744 request
.Request(host_port_pair_
,
749 callback_
.callback()));
751 EXPECT_EQ(ERR_NAME_NOT_RESOLVED
, callback_
.WaitForResult());
753 EXPECT_TRUE(socket_data
.at_read_eof());
754 EXPECT_TRUE(socket_data
.at_write_eof());
757 TEST_P(QuicStreamFactoryTest
, ConnectErrorInCreate
) {
758 MockConnect
connect(SYNCHRONOUS
, ERR_ADDRESS_IN_USE
);
759 DeterministicSocketData
socket_data(NULL
, 0, NULL
, 0);
760 socket_data
.set_connect_data(connect
);
761 socket_factory_
.AddSocketDataProvider(&socket_data
);
762 socket_data
.StopAfter(1);
764 QuicStreamRequest
request(&factory_
);
765 EXPECT_EQ(ERR_IO_PENDING
,
766 request
.Request(host_port_pair_
,
771 callback_
.callback()));
773 EXPECT_EQ(ERR_ADDRESS_IN_USE
, callback_
.WaitForResult());
775 EXPECT_TRUE(socket_data
.at_read_eof());
776 EXPECT_TRUE(socket_data
.at_write_eof());
779 TEST_P(QuicStreamFactoryTest
, CancelCreate
) {
781 MockRead(ASYNC
, OK
, 0) // EOF
783 DeterministicSocketData
socket_data(reads
, arraysize(reads
), NULL
, 0);
784 socket_factory_
.AddSocketDataProvider(&socket_data
);
786 QuicStreamRequest
request(&factory_
);
787 EXPECT_EQ(ERR_IO_PENDING
,
788 request
.Request(host_port_pair_
,
793 callback_
.callback()));
796 socket_data
.StopAfter(1);
797 base::RunLoop run_loop
;
798 run_loop
.RunUntilIdle();
800 scoped_ptr
<QuicHttpStream
> stream(
801 CreateIfSessionExists(host_port_pair_
, net_log_
));
802 EXPECT_TRUE(stream
.get());
805 EXPECT_TRUE(socket_data
.at_read_eof());
806 EXPECT_TRUE(socket_data
.at_write_eof());
809 TEST_P(QuicStreamFactoryTest
, CreateConsistentEphemeralPort
) {
810 // Sequentially connect to the default host, then another host, and then the
811 // default host. Verify that the default host gets a consistent ephemeral
812 // port, that is different from the other host's connection.
814 std::string other_server_name
= "other.google.com";
815 EXPECT_NE(kDefaultServerHostName
, other_server_name
);
816 HostPortPair
host_port_pair2(other_server_name
, kDefaultServerPort
);
818 int original_port
= GetSourcePortForNewSession(host_port_pair_
);
819 EXPECT_NE(original_port
, GetSourcePortForNewSession(host_port_pair2
));
820 EXPECT_EQ(original_port
, GetSourcePortForNewSession(host_port_pair_
));
823 TEST_P(QuicStreamFactoryTest
, GoAwayDisablesConsistentEphemeralPort
) {
824 // Get a session to the host using the port suggester.
826 GetSourcePortForNewSessionAndGoAway(host_port_pair_
);
827 // Verify that the port is different after the goaway.
828 EXPECT_NE(original_port
, GetSourcePortForNewSession(host_port_pair_
));
829 // Since the previous session did not goaway we should see the original port.
830 EXPECT_EQ(original_port
, GetSourcePortForNewSession(host_port_pair_
));
833 TEST_P(QuicStreamFactoryTest
, CloseAllSessions
) {
835 MockRead(ASYNC
, 0, 0) // EOF
837 scoped_ptr
<QuicEncryptedPacket
> rst(ConstructRstPacket());
838 std::vector
<MockWrite
> writes
;
839 writes
.push_back(MockWrite(ASYNC
, rst
->data(), rst
->length(), 1));
840 DeterministicSocketData
socket_data(reads
, arraysize(reads
),
841 writes
.empty() ? NULL
: &writes
[0],
843 socket_factory_
.AddSocketDataProvider(&socket_data
);
844 socket_data
.StopAfter(1);
846 MockRead reads2
[] = {
847 MockRead(ASYNC
, 0, 0) // EOF
849 DeterministicSocketData
socket_data2(reads2
, arraysize(reads2
), NULL
, 0);
850 socket_factory_
.AddSocketDataProvider(&socket_data2
);
851 socket_data2
.StopAfter(1);
853 QuicStreamRequest
request(&factory_
);
854 EXPECT_EQ(ERR_IO_PENDING
,
855 request
.Request(host_port_pair_
,
860 callback_
.callback()));
862 EXPECT_EQ(OK
, callback_
.WaitForResult());
863 scoped_ptr
<QuicHttpStream
> stream
= request
.ReleaseStream();
864 HttpRequestInfo request_info
;
865 EXPECT_EQ(OK
, stream
->InitializeStream(&request_info
,
867 net_log_
, CompletionCallback()));
869 // Close the session and verify that stream saw the error.
870 factory_
.CloseAllSessions(ERR_INTERNET_DISCONNECTED
);
871 EXPECT_EQ(ERR_INTERNET_DISCONNECTED
,
872 stream
->ReadResponseHeaders(callback_
.callback()));
874 // Now attempting to request a stream to the same origin should create
877 QuicStreamRequest
request2(&factory_
);
878 EXPECT_EQ(ERR_IO_PENDING
,
879 request2
.Request(host_port_pair_
,
884 callback_
.callback()));
886 EXPECT_EQ(OK
, callback_
.WaitForResult());
887 stream
= request2
.ReleaseStream();
888 stream
.reset(); // Will reset stream 3.
890 EXPECT_TRUE(socket_data
.at_read_eof());
891 EXPECT_TRUE(socket_data
.at_write_eof());
892 EXPECT_TRUE(socket_data2
.at_read_eof());
893 EXPECT_TRUE(socket_data2
.at_write_eof());
896 TEST_P(QuicStreamFactoryTest
, OnIPAddressChanged
) {
898 MockRead(ASYNC
, 0, 0) // EOF
900 scoped_ptr
<QuicEncryptedPacket
> rst(ConstructRstPacket());
901 std::vector
<MockWrite
> writes
;
902 writes
.push_back(MockWrite(ASYNC
, rst
->data(), rst
->length(), 1));
903 DeterministicSocketData
socket_data(reads
, arraysize(reads
),
904 writes
.empty() ? NULL
: &writes
[0],
906 socket_factory_
.AddSocketDataProvider(&socket_data
);
907 socket_data
.StopAfter(1);
909 MockRead reads2
[] = {
910 MockRead(ASYNC
, 0, 0) // EOF
912 DeterministicSocketData
socket_data2(reads2
, arraysize(reads2
), NULL
, 0);
913 socket_factory_
.AddSocketDataProvider(&socket_data2
);
914 socket_data2
.StopAfter(1);
916 QuicStreamRequest
request(&factory_
);
917 EXPECT_EQ(ERR_IO_PENDING
,
918 request
.Request(host_port_pair_
,
923 callback_
.callback()));
925 EXPECT_EQ(OK
, callback_
.WaitForResult());
926 scoped_ptr
<QuicHttpStream
> stream
= request
.ReleaseStream();
927 HttpRequestInfo request_info
;
928 EXPECT_EQ(OK
, stream
->InitializeStream(&request_info
,
930 net_log_
, CompletionCallback()));
932 // Change the IP address and verify that stream saw the error.
933 factory_
.OnIPAddressChanged();
934 EXPECT_EQ(ERR_NETWORK_CHANGED
,
935 stream
->ReadResponseHeaders(callback_
.callback()));
936 EXPECT_TRUE(factory_
.require_confirmation());
938 // Now attempting to request a stream to the same origin should create
941 QuicStreamRequest
request2(&factory_
);
942 EXPECT_EQ(ERR_IO_PENDING
,
943 request2
.Request(host_port_pair_
,
948 callback_
.callback()));
950 EXPECT_EQ(OK
, callback_
.WaitForResult());
951 stream
= request2
.ReleaseStream();
952 stream
.reset(); // Will reset stream 3.
954 EXPECT_TRUE(socket_data
.at_read_eof());
955 EXPECT_TRUE(socket_data
.at_write_eof());
956 EXPECT_TRUE(socket_data2
.at_read_eof());
957 EXPECT_TRUE(socket_data2
.at_write_eof());
960 TEST_P(QuicStreamFactoryTest
, OnCertAdded
) {
962 MockRead(ASYNC
, 0, 0) // EOF
964 scoped_ptr
<QuicEncryptedPacket
> rst(ConstructRstPacket());
965 std::vector
<MockWrite
> writes
;
966 writes
.push_back(MockWrite(ASYNC
, rst
->data(), rst
->length(), 1));
967 DeterministicSocketData
socket_data(reads
, arraysize(reads
),
968 writes
.empty() ? NULL
: &writes
[0],
970 socket_factory_
.AddSocketDataProvider(&socket_data
);
971 socket_data
.StopAfter(1);
973 MockRead reads2
[] = {
974 MockRead(ASYNC
, 0, 0) // EOF
976 DeterministicSocketData
socket_data2(reads2
, arraysize(reads2
), NULL
, 0);
977 socket_factory_
.AddSocketDataProvider(&socket_data2
);
978 socket_data2
.StopAfter(1);
980 QuicStreamRequest
request(&factory_
);
981 EXPECT_EQ(ERR_IO_PENDING
,
982 request
.Request(host_port_pair_
,
987 callback_
.callback()));
989 EXPECT_EQ(OK
, callback_
.WaitForResult());
990 scoped_ptr
<QuicHttpStream
> stream
= request
.ReleaseStream();
991 HttpRequestInfo request_info
;
992 EXPECT_EQ(OK
, stream
->InitializeStream(&request_info
,
994 net_log_
, CompletionCallback()));
996 // Add a cert and verify that stream saw the event.
997 factory_
.OnCertAdded(NULL
);
998 EXPECT_EQ(ERR_CERT_DATABASE_CHANGED
,
999 stream
->ReadResponseHeaders(callback_
.callback()));
1000 EXPECT_FALSE(factory_
.require_confirmation());
1002 // Now attempting to request a stream to the same origin should create
1005 QuicStreamRequest
request2(&factory_
);
1006 EXPECT_EQ(ERR_IO_PENDING
,
1007 request2
.Request(host_port_pair_
,
1012 callback_
.callback()));
1014 EXPECT_EQ(OK
, callback_
.WaitForResult());
1015 stream
= request2
.ReleaseStream();
1016 stream
.reset(); // Will reset stream 3.
1018 EXPECT_TRUE(socket_data
.at_read_eof());
1019 EXPECT_TRUE(socket_data
.at_write_eof());
1020 EXPECT_TRUE(socket_data2
.at_read_eof());
1021 EXPECT_TRUE(socket_data2
.at_write_eof());
1024 TEST_P(QuicStreamFactoryTest
, OnCACertChanged
) {
1025 MockRead reads
[] = {
1026 MockRead(ASYNC
, 0, 0) // EOF
1028 scoped_ptr
<QuicEncryptedPacket
> rst(ConstructRstPacket());
1029 std::vector
<MockWrite
> writes
;
1030 writes
.push_back(MockWrite(ASYNC
, rst
->data(), rst
->length(), 1));
1031 DeterministicSocketData
socket_data(reads
, arraysize(reads
),
1032 writes
.empty() ? NULL
: &writes
[0],
1034 socket_factory_
.AddSocketDataProvider(&socket_data
);
1035 socket_data
.StopAfter(1);
1037 MockRead reads2
[] = {
1038 MockRead(ASYNC
, 0, 0) // EOF
1040 DeterministicSocketData
socket_data2(reads2
, arraysize(reads2
), NULL
, 0);
1041 socket_factory_
.AddSocketDataProvider(&socket_data2
);
1042 socket_data2
.StopAfter(1);
1044 QuicStreamRequest
request(&factory_
);
1045 EXPECT_EQ(ERR_IO_PENDING
,
1046 request
.Request(host_port_pair_
,
1051 callback_
.callback()));
1053 EXPECT_EQ(OK
, callback_
.WaitForResult());
1054 scoped_ptr
<QuicHttpStream
> stream
= request
.ReleaseStream();
1055 HttpRequestInfo request_info
;
1056 EXPECT_EQ(OK
, stream
->InitializeStream(&request_info
,
1058 net_log_
, CompletionCallback()));
1060 // Change the CA cert and verify that stream saw the event.
1061 factory_
.OnCACertChanged(NULL
);
1062 EXPECT_EQ(ERR_CERT_DATABASE_CHANGED
,
1063 stream
->ReadResponseHeaders(callback_
.callback()));
1064 EXPECT_FALSE(factory_
.require_confirmation());
1066 // Now attempting to request a stream to the same origin should create
1069 QuicStreamRequest
request2(&factory_
);
1070 EXPECT_EQ(ERR_IO_PENDING
,
1071 request2
.Request(host_port_pair_
,
1076 callback_
.callback()));
1078 EXPECT_EQ(OK
, callback_
.WaitForResult());
1079 stream
= request2
.ReleaseStream();
1080 stream
.reset(); // Will reset stream 3.
1082 EXPECT_TRUE(socket_data
.at_read_eof());
1083 EXPECT_TRUE(socket_data
.at_write_eof());
1084 EXPECT_TRUE(socket_data2
.at_read_eof());
1085 EXPECT_TRUE(socket_data2
.at_write_eof());
1088 TEST_P(QuicStreamFactoryTest
, SharedCryptoConfig
) {
1089 vector
<string
> cannoncial_suffixes
;
1090 cannoncial_suffixes
.push_back(string(".c.youtube.com"));
1091 cannoncial_suffixes
.push_back(string(".googlevideo.com"));
1093 for (unsigned i
= 0; i
< cannoncial_suffixes
.size(); ++i
) {
1094 string
r1_host_name("r1");
1095 string
r2_host_name("r2");
1096 r1_host_name
.append(cannoncial_suffixes
[i
]);
1097 r2_host_name
.append(cannoncial_suffixes
[i
]);
1099 HostPortPair
host_port_pair1(r1_host_name
, 80);
1100 QuicCryptoClientConfig
* crypto_config
=
1101 QuicStreamFactoryPeer::GetCryptoConfig(&factory_
);
1102 QuicServerId
server_id1(host_port_pair1
, is_https_
, privacy_mode_
);
1103 QuicCryptoClientConfig::CachedState
* cached1
=
1104 crypto_config
->LookupOrCreate(server_id1
);
1105 EXPECT_FALSE(cached1
->proof_valid());
1106 EXPECT_TRUE(cached1
->source_address_token().empty());
1108 // Mutate the cached1 to have different data.
1109 // TODO(rtenneti): mutate other members of CachedState.
1110 cached1
->set_source_address_token(r1_host_name
);
1111 cached1
->SetProofValid();
1113 HostPortPair
host_port_pair2(r2_host_name
, 80);
1114 QuicServerId
server_id2(host_port_pair2
, is_https_
, privacy_mode_
);
1115 QuicCryptoClientConfig::CachedState
* cached2
=
1116 crypto_config
->LookupOrCreate(server_id2
);
1117 EXPECT_EQ(cached1
->source_address_token(), cached2
->source_address_token());
1118 EXPECT_TRUE(cached2
->proof_valid());
1122 TEST_P(QuicStreamFactoryTest
, CryptoConfigWhenProofIsInvalid
) {
1123 vector
<string
> cannoncial_suffixes
;
1124 cannoncial_suffixes
.push_back(string(".c.youtube.com"));
1125 cannoncial_suffixes
.push_back(string(".googlevideo.com"));
1127 for (unsigned i
= 0; i
< cannoncial_suffixes
.size(); ++i
) {
1128 string
r3_host_name("r3");
1129 string
r4_host_name("r4");
1130 r3_host_name
.append(cannoncial_suffixes
[i
]);
1131 r4_host_name
.append(cannoncial_suffixes
[i
]);
1133 HostPortPair
host_port_pair1(r3_host_name
, 80);
1134 QuicCryptoClientConfig
* crypto_config
=
1135 QuicStreamFactoryPeer::GetCryptoConfig(&factory_
);
1136 QuicServerId
server_id1(host_port_pair1
, is_https_
, privacy_mode_
);
1137 QuicCryptoClientConfig::CachedState
* cached1
=
1138 crypto_config
->LookupOrCreate(server_id1
);
1139 EXPECT_FALSE(cached1
->proof_valid());
1140 EXPECT_TRUE(cached1
->source_address_token().empty());
1142 // Mutate the cached1 to have different data.
1143 // TODO(rtenneti): mutate other members of CachedState.
1144 cached1
->set_source_address_token(r3_host_name
);
1145 cached1
->SetProofInvalid();
1147 HostPortPair
host_port_pair2(r4_host_name
, 80);
1148 QuicServerId
server_id2(host_port_pair2
, is_https_
, privacy_mode_
);
1149 QuicCryptoClientConfig::CachedState
* cached2
=
1150 crypto_config
->LookupOrCreate(server_id2
);
1151 EXPECT_NE(cached1
->source_address_token(), cached2
->source_address_token());
1152 EXPECT_TRUE(cached2
->source_address_token().empty());
1153 EXPECT_FALSE(cached2
->proof_valid());