Chromium Code Reviews
chromiumcodereview-hr@appspot.gserviceaccount.com (chromiumcodereview-hr) | Please choose your nickname with Settings | Help | Chromium Project | Gerrit Changes | Sign out
(592)

Side by Side Diff: net/spdy/spdy_session_pool_unittest.cc

Issue 2351513002: net: rename BoundNetLog to NetLogWithSource (Closed)
Patch Set: one more fix, content bound_net_log_ Created 4 years, 3 months ago
Use n/p to move between diff chunks; N/P to move between comments. Draft comments are only viewable by you.
Jump to:
View unified diff | Download patch
OLDNEW
1 // Copyright (c) 2013 The Chromium Authors. All rights reserved. 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 2 // Use of this source code is governed by a BSD-style license that can be
3 // found in the LICENSE file. 3 // found in the LICENSE file.
4 4
5 #include "net/spdy/spdy_session_pool.h" 5 #include "net/spdy/spdy_session_pool.h"
6 6
7 #include <cstddef> 7 #include <cstddef>
8 #include <memory> 8 #include <memory>
9 #include <string> 9 #include <string>
10 #include <utility> 10 #include <utility>
(...skipping 93 matching lines...) Expand 10 before | Expand all | Expand 10 after
104 StaticSocketDataProvider data(reads, arraysize(reads), NULL, 0); 104 StaticSocketDataProvider data(reads, arraysize(reads), NULL, 0);
105 data.set_connect_data(connect_data); 105 data.set_connect_data(connect_data);
106 session_deps_.socket_factory->AddSocketDataProvider(&data); 106 session_deps_.socket_factory->AddSocketDataProvider(&data);
107 107
108 SSLSocketDataProvider ssl(SYNCHRONOUS, OK); 108 SSLSocketDataProvider ssl(SYNCHRONOUS, OK);
109 session_deps_.socket_factory->AddSSLSocketDataProvider(&ssl); 109 session_deps_.socket_factory->AddSSLSocketDataProvider(&ssl);
110 110
111 CreateNetworkSession(); 111 CreateNetworkSession();
112 112
113 // Setup the first session to the first host. 113 // Setup the first session to the first host.
114 base::WeakPtr<SpdySession> session = 114 base::WeakPtr<SpdySession> session = CreateInsecureSpdySession(
115 CreateInsecureSpdySession(http_session_.get(), test_key, BoundNetLog()); 115 http_session_.get(), test_key, NetLogWithSource());
116 116
117 // Flush the SpdySession::OnReadComplete() task. 117 // Flush the SpdySession::OnReadComplete() task.
118 base::RunLoop().RunUntilIdle(); 118 base::RunLoop().RunUntilIdle();
119 119
120 // Verify that we have sessions for everything. 120 // Verify that we have sessions for everything.
121 EXPECT_TRUE(HasSpdySession(spdy_session_pool_, test_key)); 121 EXPECT_TRUE(HasSpdySession(spdy_session_pool_, test_key));
122 122
123 // Set the stream to create a new session when it is closed. 123 // Set the stream to create a new session when it is closed.
124 base::WeakPtr<SpdyStream> spdy_stream = 124 base::WeakPtr<SpdyStream> spdy_stream = CreateStreamSynchronously(
125 CreateStreamSynchronously(SPDY_BIDIRECTIONAL_STREAM, 125 SPDY_BIDIRECTIONAL_STREAM, session, GURL("http://www.foo.com"), MEDIUM,
126 session, GURL("http://www.foo.com"), 126 NetLogWithSource());
127 MEDIUM, BoundNetLog());
128 SessionOpeningDelegate delegate(spdy_session_pool_, test_key); 127 SessionOpeningDelegate delegate(spdy_session_pool_, test_key);
129 spdy_stream->SetDelegate(&delegate); 128 spdy_stream->SetDelegate(&delegate);
130 129
131 // Close the current session. 130 // Close the current session.
132 spdy_session_pool_->CloseCurrentSessions(ERR_ABORTED); 131 spdy_session_pool_->CloseCurrentSessions(ERR_ABORTED);
133 132
134 EXPECT_TRUE(HasSpdySession(spdy_session_pool_, test_key)); 133 EXPECT_TRUE(HasSpdySession(spdy_session_pool_, test_key));
135 } 134 }
136 135
137 TEST_F(SpdySessionPoolTest, CloseCurrentIdleSessions) { 136 TEST_F(SpdySessionPoolTest, CloseCurrentIdleSessions) {
(...skipping 12 matching lines...) Expand all
150 session_deps_.socket_factory->AddSSLSocketDataProvider(&ssl); 149 session_deps_.socket_factory->AddSSLSocketDataProvider(&ssl);
151 150
152 CreateNetworkSession(); 151 CreateNetworkSession();
153 152
154 // Set up session 1 153 // Set up session 1
155 const std::string kTestHost1("http://www.a.com"); 154 const std::string kTestHost1("http://www.a.com");
156 HostPortPair test_host_port_pair1(kTestHost1, 80); 155 HostPortPair test_host_port_pair1(kTestHost1, 80);
157 SpdySessionKey key1(test_host_port_pair1, ProxyServer::Direct(), 156 SpdySessionKey key1(test_host_port_pair1, ProxyServer::Direct(),
158 PRIVACY_MODE_DISABLED); 157 PRIVACY_MODE_DISABLED);
159 base::WeakPtr<SpdySession> session1 = 158 base::WeakPtr<SpdySession> session1 =
160 CreateInsecureSpdySession(http_session_.get(), key1, BoundNetLog()); 159 CreateInsecureSpdySession(http_session_.get(), key1, NetLogWithSource());
161 GURL url1(kTestHost1); 160 GURL url1(kTestHost1);
162 base::WeakPtr<SpdyStream> spdy_stream1 = 161 base::WeakPtr<SpdyStream> spdy_stream1 = CreateStreamSynchronously(
163 CreateStreamSynchronously(SPDY_BIDIRECTIONAL_STREAM, 162 SPDY_BIDIRECTIONAL_STREAM, session1, url1, MEDIUM, NetLogWithSource());
164 session1, url1, MEDIUM, BoundNetLog());
165 ASSERT_TRUE(spdy_stream1); 163 ASSERT_TRUE(spdy_stream1);
166 164
167 // Set up session 2 165 // Set up session 2
168 StaticSocketDataProvider data2(reads, arraysize(reads), nullptr, 0); 166 StaticSocketDataProvider data2(reads, arraysize(reads), nullptr, 0);
169 data2.set_connect_data(connect_data); 167 data2.set_connect_data(connect_data);
170 session_deps_.socket_factory->AddSocketDataProvider(&data2); 168 session_deps_.socket_factory->AddSocketDataProvider(&data2);
171 const std::string kTestHost2("http://www.b.com"); 169 const std::string kTestHost2("http://www.b.com");
172 HostPortPair test_host_port_pair2(kTestHost2, 80); 170 HostPortPair test_host_port_pair2(kTestHost2, 80);
173 SpdySessionKey key2(test_host_port_pair2, ProxyServer::Direct(), 171 SpdySessionKey key2(test_host_port_pair2, ProxyServer::Direct(),
174 PRIVACY_MODE_DISABLED); 172 PRIVACY_MODE_DISABLED);
175 base::WeakPtr<SpdySession> session2 = 173 base::WeakPtr<SpdySession> session2 =
176 CreateInsecureSpdySession(http_session_.get(), key2, BoundNetLog()); 174 CreateInsecureSpdySession(http_session_.get(), key2, NetLogWithSource());
177 GURL url2(kTestHost2); 175 GURL url2(kTestHost2);
178 base::WeakPtr<SpdyStream> spdy_stream2 = 176 base::WeakPtr<SpdyStream> spdy_stream2 = CreateStreamSynchronously(
179 CreateStreamSynchronously(SPDY_BIDIRECTIONAL_STREAM, 177 SPDY_BIDIRECTIONAL_STREAM, session2, url2, MEDIUM, NetLogWithSource());
180 session2, url2, MEDIUM, BoundNetLog());
181 ASSERT_TRUE(spdy_stream2); 178 ASSERT_TRUE(spdy_stream2);
182 179
183 // Set up session 3 180 // Set up session 3
184 StaticSocketDataProvider data3(reads, arraysize(reads), nullptr, 0); 181 StaticSocketDataProvider data3(reads, arraysize(reads), nullptr, 0);
185 data3.set_connect_data(connect_data); 182 data3.set_connect_data(connect_data);
186 session_deps_.socket_factory->AddSocketDataProvider(&data3); 183 session_deps_.socket_factory->AddSocketDataProvider(&data3);
187 const std::string kTestHost3("http://www.c.com"); 184 const std::string kTestHost3("http://www.c.com");
188 HostPortPair test_host_port_pair3(kTestHost3, 80); 185 HostPortPair test_host_port_pair3(kTestHost3, 80);
189 SpdySessionKey key3(test_host_port_pair3, ProxyServer::Direct(), 186 SpdySessionKey key3(test_host_port_pair3, ProxyServer::Direct(),
190 PRIVACY_MODE_DISABLED); 187 PRIVACY_MODE_DISABLED);
191 base::WeakPtr<SpdySession> session3 = 188 base::WeakPtr<SpdySession> session3 =
192 CreateInsecureSpdySession(http_session_.get(), key3, BoundNetLog()); 189 CreateInsecureSpdySession(http_session_.get(), key3, NetLogWithSource());
193 GURL url3(kTestHost3); 190 GURL url3(kTestHost3);
194 base::WeakPtr<SpdyStream> spdy_stream3 = 191 base::WeakPtr<SpdyStream> spdy_stream3 = CreateStreamSynchronously(
195 CreateStreamSynchronously(SPDY_BIDIRECTIONAL_STREAM, 192 SPDY_BIDIRECTIONAL_STREAM, session3, url3, MEDIUM, NetLogWithSource());
196 session3, url3, MEDIUM, BoundNetLog());
197 ASSERT_TRUE(spdy_stream3); 193 ASSERT_TRUE(spdy_stream3);
198 194
199 // All sessions are active and not closed 195 // All sessions are active and not closed
200 EXPECT_TRUE(session1->is_active()); 196 EXPECT_TRUE(session1->is_active());
201 EXPECT_TRUE(session1->IsAvailable()); 197 EXPECT_TRUE(session1->IsAvailable());
202 EXPECT_TRUE(session2->is_active()); 198 EXPECT_TRUE(session2->is_active());
203 EXPECT_TRUE(session2->IsAvailable()); 199 EXPECT_TRUE(session2->IsAvailable());
204 EXPECT_TRUE(session3->is_active()); 200 EXPECT_TRUE(session3->is_active());
205 EXPECT_TRUE(session3->IsAvailable()); 201 EXPECT_TRUE(session3->IsAvailable());
206 202
(...skipping 72 matching lines...) Expand 10 before | Expand all | Expand 10 after
279 StaticSocketDataProvider data(reads, arraysize(reads), NULL, 0); 275 StaticSocketDataProvider data(reads, arraysize(reads), NULL, 0);
280 data.set_connect_data(connect_data); 276 data.set_connect_data(connect_data);
281 session_deps_.socket_factory->AddSocketDataProvider(&data); 277 session_deps_.socket_factory->AddSocketDataProvider(&data);
282 278
283 SSLSocketDataProvider ssl(SYNCHRONOUS, OK); 279 SSLSocketDataProvider ssl(SYNCHRONOUS, OK);
284 session_deps_.socket_factory->AddSSLSocketDataProvider(&ssl); 280 session_deps_.socket_factory->AddSSLSocketDataProvider(&ssl);
285 281
286 CreateNetworkSession(); 282 CreateNetworkSession();
287 283
288 // Setup the first session to the first host. 284 // Setup the first session to the first host.
289 base::WeakPtr<SpdySession> session = 285 base::WeakPtr<SpdySession> session = CreateInsecureSpdySession(
290 CreateInsecureSpdySession(http_session_.get(), test_key, BoundNetLog()); 286 http_session_.get(), test_key, NetLogWithSource());
291 287
292 // Flush the SpdySession::OnReadComplete() task. 288 // Flush the SpdySession::OnReadComplete() task.
293 base::RunLoop().RunUntilIdle(); 289 base::RunLoop().RunUntilIdle();
294 290
295 // Verify that we have sessions for everything. 291 // Verify that we have sessions for everything.
296 EXPECT_TRUE(HasSpdySession(spdy_session_pool_, test_key)); 292 EXPECT_TRUE(HasSpdySession(spdy_session_pool_, test_key));
297 293
298 // Set the stream to create a new session when it is closed. 294 // Set the stream to create a new session when it is closed.
299 base::WeakPtr<SpdyStream> spdy_stream = 295 base::WeakPtr<SpdyStream> spdy_stream = CreateStreamSynchronously(
300 CreateStreamSynchronously(SPDY_BIDIRECTIONAL_STREAM, 296 SPDY_BIDIRECTIONAL_STREAM, session, GURL("http://www.foo.com"), MEDIUM,
301 session, GURL("http://www.foo.com"), 297 NetLogWithSource());
302 MEDIUM, BoundNetLog());
303 SessionOpeningDelegate delegate(spdy_session_pool_, test_key); 298 SessionOpeningDelegate delegate(spdy_session_pool_, test_key);
304 spdy_stream->SetDelegate(&delegate); 299 spdy_stream->SetDelegate(&delegate);
305 300
306 // Close the current session. 301 // Close the current session.
307 spdy_session_pool_->CloseAllSessions(); 302 spdy_session_pool_->CloseAllSessions();
308 303
309 EXPECT_FALSE(HasSpdySession(spdy_session_pool_, test_key)); 304 EXPECT_FALSE(HasSpdySession(spdy_session_pool_, test_key));
310 } 305 }
311 306
312 // This test has three variants, one for each style of closing the connection. 307 // This test has three variants, one for each style of closing the connection.
(...skipping 31 matching lines...) Expand 10 before | Expand all | Expand 10 after
344 std::unique_ptr<HostResolver::Request> request[arraysize(test_hosts)]; 339 std::unique_ptr<HostResolver::Request> request[arraysize(test_hosts)];
345 for (size_t i = 0; i < arraysize(test_hosts); i++) { 340 for (size_t i = 0; i < arraysize(test_hosts); i++) {
346 session_deps_.host_resolver->rules()->AddIPLiteralRule( 341 session_deps_.host_resolver->rules()->AddIPLiteralRule(
347 test_hosts[i].name, test_hosts[i].iplist, std::string()); 342 test_hosts[i].name, test_hosts[i].iplist, std::string());
348 343
349 // This test requires that the HostResolver cache be populated. Normal 344 // This test requires that the HostResolver cache be populated. Normal
350 // code would have done this already, but we do it manually. 345 // code would have done this already, but we do it manually.
351 HostResolver::RequestInfo info(HostPortPair(test_hosts[i].name, kTestPort)); 346 HostResolver::RequestInfo info(HostPortPair(test_hosts[i].name, kTestPort));
352 session_deps_.host_resolver->Resolve( 347 session_deps_.host_resolver->Resolve(
353 info, DEFAULT_PRIORITY, &test_hosts[i].addresses, CompletionCallback(), 348 info, DEFAULT_PRIORITY, &test_hosts[i].addresses, CompletionCallback(),
354 &request[i], BoundNetLog()); 349 &request[i], NetLogWithSource());
355 350
356 // Setup a SpdySessionKey 351 // Setup a SpdySessionKey
357 test_hosts[i].key = SpdySessionKey( 352 test_hosts[i].key = SpdySessionKey(
358 HostPortPair(test_hosts[i].name, kTestPort), ProxyServer::Direct(), 353 HostPortPair(test_hosts[i].name, kTestPort), ProxyServer::Direct(),
359 PRIVACY_MODE_DISABLED); 354 PRIVACY_MODE_DISABLED);
360 } 355 }
361 356
362 MockConnect connect_data(SYNCHRONOUS, OK); 357 MockConnect connect_data(SYNCHRONOUS, OK);
363 MockRead reads[] = { 358 MockRead reads[] = {
364 MockRead(SYNCHRONOUS, ERR_IO_PENDING) // Stall forever. 359 MockRead(SYNCHRONOUS, ERR_IO_PENDING) // Stall forever.
365 }; 360 };
366 361
367 StaticSocketDataProvider data1(reads, arraysize(reads), NULL, 0); 362 StaticSocketDataProvider data1(reads, arraysize(reads), NULL, 0);
368 data1.set_connect_data(connect_data); 363 data1.set_connect_data(connect_data);
369 session_deps_.socket_factory->AddSocketDataProvider(&data1); 364 session_deps_.socket_factory->AddSocketDataProvider(&data1);
370 365
371 SSLSocketDataProvider ssl(SYNCHRONOUS, OK); 366 SSLSocketDataProvider ssl(SYNCHRONOUS, OK);
372 session_deps_.socket_factory->AddSSLSocketDataProvider(&ssl); 367 session_deps_.socket_factory->AddSSLSocketDataProvider(&ssl);
373 368
374 CreateNetworkSession(); 369 CreateNetworkSession();
375 370
376 // Setup the first session to the first host. 371 // Setup the first session to the first host.
377 base::WeakPtr<SpdySession> session = CreateInsecureSpdySession( 372 base::WeakPtr<SpdySession> session = CreateInsecureSpdySession(
378 http_session_.get(), test_hosts[0].key, BoundNetLog()); 373 http_session_.get(), test_hosts[0].key, NetLogWithSource());
379 374
380 // Flush the SpdySession::OnReadComplete() task. 375 // Flush the SpdySession::OnReadComplete() task.
381 base::RunLoop().RunUntilIdle(); 376 base::RunLoop().RunUntilIdle();
382 377
383 // The third host has no overlap with the first, so it can't pool IPs. 378 // The third host has no overlap with the first, so it can't pool IPs.
384 EXPECT_FALSE(HasSpdySession(spdy_session_pool_, test_hosts[2].key)); 379 EXPECT_FALSE(HasSpdySession(spdy_session_pool_, test_hosts[2].key));
385 380
386 // The second host overlaps with the first, and should IP pool. 381 // The second host overlaps with the first, and should IP pool.
387 EXPECT_TRUE(HasSpdySession(spdy_session_pool_, test_hosts[1].key)); 382 EXPECT_TRUE(HasSpdySession(spdy_session_pool_, test_hosts[1].key));
388 383
389 // Verify that the second host, through a proxy, won't share the IP. 384 // Verify that the second host, through a proxy, won't share the IP.
390 SpdySessionKey proxy_key(test_hosts[1].key.host_port_pair(), 385 SpdySessionKey proxy_key(test_hosts[1].key.host_port_pair(),
391 ProxyServer::FromPacString("HTTP http://proxy.foo.com/"), 386 ProxyServer::FromPacString("HTTP http://proxy.foo.com/"),
392 PRIVACY_MODE_DISABLED); 387 PRIVACY_MODE_DISABLED);
393 EXPECT_FALSE(HasSpdySession(spdy_session_pool_, proxy_key)); 388 EXPECT_FALSE(HasSpdySession(spdy_session_pool_, proxy_key));
394 389
395 // Overlap between 2 and 3 does is not transitive to 1. 390 // Overlap between 2 and 3 does is not transitive to 1.
396 EXPECT_FALSE(HasSpdySession(spdy_session_pool_, test_hosts[2].key)); 391 EXPECT_FALSE(HasSpdySession(spdy_session_pool_, test_hosts[2].key));
397 392
398 // Create a new session to host 2. 393 // Create a new session to host 2.
399 StaticSocketDataProvider data2(reads, arraysize(reads), NULL, 0); 394 StaticSocketDataProvider data2(reads, arraysize(reads), NULL, 0);
400 data2.set_connect_data(connect_data); 395 data2.set_connect_data(connect_data);
401 session_deps_.socket_factory->AddSocketDataProvider(&data2); 396 session_deps_.socket_factory->AddSocketDataProvider(&data2);
402 base::WeakPtr<SpdySession> session2 = CreateInsecureSpdySession( 397 base::WeakPtr<SpdySession> session2 = CreateInsecureSpdySession(
403 http_session_.get(), test_hosts[2].key, BoundNetLog()); 398 http_session_.get(), test_hosts[2].key, NetLogWithSource());
404 399
405 // Verify that we have sessions for everything. 400 // Verify that we have sessions for everything.
406 EXPECT_TRUE(HasSpdySession(spdy_session_pool_, test_hosts[0].key)); 401 EXPECT_TRUE(HasSpdySession(spdy_session_pool_, test_hosts[0].key));
407 EXPECT_TRUE(HasSpdySession(spdy_session_pool_, test_hosts[1].key)); 402 EXPECT_TRUE(HasSpdySession(spdy_session_pool_, test_hosts[1].key));
408 EXPECT_TRUE(HasSpdySession(spdy_session_pool_, test_hosts[2].key)); 403 EXPECT_TRUE(HasSpdySession(spdy_session_pool_, test_hosts[2].key));
409 404
410 // Grab the session to host 1 and verify that it is the same session 405 // Grab the session to host 1 and verify that it is the same session
411 // we got with host 0, and that is a different from host 2's session. 406 // we got with host 0, and that is a different from host 2's session.
412 base::WeakPtr<SpdySession> session1 = 407 base::WeakPtr<SpdySession> session1 =
413 spdy_session_pool_->FindAvailableSession( 408 spdy_session_pool_->FindAvailableSession(
414 test_hosts[1].key, GURL(test_hosts[1].url), BoundNetLog()); 409 test_hosts[1].key, GURL(test_hosts[1].url), NetLogWithSource());
415 EXPECT_EQ(session.get(), session1.get()); 410 EXPECT_EQ(session.get(), session1.get());
416 EXPECT_NE(session2.get(), session1.get()); 411 EXPECT_NE(session2.get(), session1.get());
417 412
418 // Remove the aliases and observe that we still have a session for host1. 413 // Remove the aliases and observe that we still have a session for host1.
419 SpdySessionPoolPeer pool_peer(spdy_session_pool_); 414 SpdySessionPoolPeer pool_peer(spdy_session_pool_);
420 pool_peer.RemoveAliases(test_hosts[0].key); 415 pool_peer.RemoveAliases(test_hosts[0].key);
421 pool_peer.RemoveAliases(test_hosts[1].key); 416 pool_peer.RemoveAliases(test_hosts[1].key);
422 EXPECT_TRUE(HasSpdySession(spdy_session_pool_, test_hosts[1].key)); 417 EXPECT_TRUE(HasSpdySession(spdy_session_pool_, test_hosts[1].key));
423 418
424 // Expire the host cache 419 // Expire the host cache
425 session_deps_.host_resolver->GetHostCache()->clear(); 420 session_deps_.host_resolver->GetHostCache()->clear();
426 EXPECT_TRUE(HasSpdySession(spdy_session_pool_, test_hosts[1].key)); 421 EXPECT_TRUE(HasSpdySession(spdy_session_pool_, test_hosts[1].key));
427 422
428 // Cleanup the sessions. 423 // Cleanup the sessions.
429 switch (close_sessions_type) { 424 switch (close_sessions_type) {
430 case SPDY_POOL_CLOSE_SESSIONS_MANUALLY: 425 case SPDY_POOL_CLOSE_SESSIONS_MANUALLY:
431 session->CloseSessionOnError(ERR_ABORTED, std::string()); 426 session->CloseSessionOnError(ERR_ABORTED, std::string());
432 session2->CloseSessionOnError(ERR_ABORTED, std::string()); 427 session2->CloseSessionOnError(ERR_ABORTED, std::string());
433 base::RunLoop().RunUntilIdle(); 428 base::RunLoop().RunUntilIdle();
434 EXPECT_FALSE(session); 429 EXPECT_FALSE(session);
435 EXPECT_FALSE(session2); 430 EXPECT_FALSE(session2);
436 break; 431 break;
437 case SPDY_POOL_CLOSE_CURRENT_SESSIONS: 432 case SPDY_POOL_CLOSE_CURRENT_SESSIONS:
438 spdy_session_pool_->CloseCurrentSessions(ERR_ABORTED); 433 spdy_session_pool_->CloseCurrentSessions(ERR_ABORTED);
439 break; 434 break;
440 case SPDY_POOL_CLOSE_IDLE_SESSIONS: 435 case SPDY_POOL_CLOSE_IDLE_SESSIONS:
441 GURL url(test_hosts[0].url); 436 GURL url(test_hosts[0].url);
442 base::WeakPtr<SpdyStream> spdy_stream = 437 base::WeakPtr<SpdyStream> spdy_stream = CreateStreamSynchronously(
443 CreateStreamSynchronously(SPDY_BIDIRECTIONAL_STREAM, 438 SPDY_BIDIRECTIONAL_STREAM, session, url, MEDIUM, NetLogWithSource());
444 session, url, MEDIUM, BoundNetLog());
445 GURL url1(test_hosts[1].url); 439 GURL url1(test_hosts[1].url);
446 base::WeakPtr<SpdyStream> spdy_stream1 = 440 base::WeakPtr<SpdyStream> spdy_stream1 =
447 CreateStreamSynchronously(SPDY_BIDIRECTIONAL_STREAM, 441 CreateStreamSynchronously(SPDY_BIDIRECTIONAL_STREAM, session1, url1,
448 session1, url1, MEDIUM, BoundNetLog()); 442 MEDIUM, NetLogWithSource());
449 GURL url2(test_hosts[2].url); 443 GURL url2(test_hosts[2].url);
450 base::WeakPtr<SpdyStream> spdy_stream2 = 444 base::WeakPtr<SpdyStream> spdy_stream2 =
451 CreateStreamSynchronously(SPDY_BIDIRECTIONAL_STREAM, 445 CreateStreamSynchronously(SPDY_BIDIRECTIONAL_STREAM, session2, url2,
452 session2, url2, MEDIUM, BoundNetLog()); 446 MEDIUM, NetLogWithSource());
453 447
454 // Close streams to make spdy_session and spdy_session1 inactive. 448 // Close streams to make spdy_session and spdy_session1 inactive.
455 session->CloseCreatedStream(spdy_stream, OK); 449 session->CloseCreatedStream(spdy_stream, OK);
456 EXPECT_FALSE(spdy_stream); 450 EXPECT_FALSE(spdy_stream);
457 session1->CloseCreatedStream(spdy_stream1, OK); 451 session1->CloseCreatedStream(spdy_stream1, OK);
458 EXPECT_FALSE(spdy_stream1); 452 EXPECT_FALSE(spdy_stream1);
459 453
460 // Check spdy_session and spdy_session1 are not closed. 454 // Check spdy_session and spdy_session1 are not closed.
461 EXPECT_FALSE(session->is_active()); 455 EXPECT_FALSE(session->is_active());
462 EXPECT_TRUE(session->IsAvailable()); 456 EXPECT_TRUE(session->IsAvailable());
(...skipping 71 matching lines...) Expand 10 before | Expand all | Expand 10 after
534 session_deps_.socket_factory->AddSSLSocketDataProvider(&ssl); 528 session_deps_.socket_factory->AddSSLSocketDataProvider(&ssl);
535 529
536 CreateNetworkSession(); 530 CreateNetworkSession();
537 531
538 // Set up session A: Going away, but with an active stream. 532 // Set up session A: Going away, but with an active stream.
539 const std::string kTestHostA("http://www.a.com"); 533 const std::string kTestHostA("http://www.a.com");
540 HostPortPair test_host_port_pairA(kTestHostA, 80); 534 HostPortPair test_host_port_pairA(kTestHostA, 80);
541 SpdySessionKey keyA( 535 SpdySessionKey keyA(
542 test_host_port_pairA, ProxyServer::Direct(), PRIVACY_MODE_DISABLED); 536 test_host_port_pairA, ProxyServer::Direct(), PRIVACY_MODE_DISABLED);
543 base::WeakPtr<SpdySession> sessionA = 537 base::WeakPtr<SpdySession> sessionA =
544 CreateInsecureSpdySession(http_session_.get(), keyA, BoundNetLog()); 538 CreateInsecureSpdySession(http_session_.get(), keyA, NetLogWithSource());
545 539
546 GURL urlA(kTestHostA); 540 GURL urlA(kTestHostA);
547 base::WeakPtr<SpdyStream> spdy_streamA = CreateStreamSynchronously( 541 base::WeakPtr<SpdyStream> spdy_streamA = CreateStreamSynchronously(
548 SPDY_BIDIRECTIONAL_STREAM, sessionA, urlA, MEDIUM, BoundNetLog()); 542 SPDY_BIDIRECTIONAL_STREAM, sessionA, urlA, MEDIUM, NetLogWithSource());
549 test::StreamDelegateDoNothing delegateA(spdy_streamA); 543 test::StreamDelegateDoNothing delegateA(spdy_streamA);
550 spdy_streamA->SetDelegate(&delegateA); 544 spdy_streamA->SetDelegate(&delegateA);
551 545
552 SpdyHeaderBlock headers(spdy_util.ConstructGetHeaderBlock(urlA.spec())); 546 SpdyHeaderBlock headers(spdy_util.ConstructGetHeaderBlock(urlA.spec()));
553 spdy_streamA->SendRequestHeaders(std::move(headers), NO_MORE_DATA_TO_SEND); 547 spdy_streamA->SendRequestHeaders(std::move(headers), NO_MORE_DATA_TO_SEND);
554 548
555 base::RunLoop().RunUntilIdle(); // Allow headers to write. 549 base::RunLoop().RunUntilIdle(); // Allow headers to write.
556 EXPECT_TRUE(delegateA.send_headers_completed()); 550 EXPECT_TRUE(delegateA.send_headers_completed());
557 551
558 sessionA->MakeUnavailable(); 552 sessionA->MakeUnavailable();
559 EXPECT_TRUE(sessionA->IsGoingAway()); 553 EXPECT_TRUE(sessionA->IsGoingAway());
560 EXPECT_FALSE(delegateA.StreamIsClosed()); 554 EXPECT_FALSE(delegateA.StreamIsClosed());
561 555
562 // Set up session B: Available, with a created stream. 556 // Set up session B: Available, with a created stream.
563 StaticSocketDataProvider dataB(reads, arraysize(reads), writes, 557 StaticSocketDataProvider dataB(reads, arraysize(reads), writes,
564 arraysize(writes)); 558 arraysize(writes));
565 dataB.set_connect_data(connect_data); 559 dataB.set_connect_data(connect_data);
566 session_deps_.socket_factory->AddSocketDataProvider(&dataB); 560 session_deps_.socket_factory->AddSocketDataProvider(&dataB);
567 const std::string kTestHostB("http://www.b.com"); 561 const std::string kTestHostB("http://www.b.com");
568 HostPortPair test_host_port_pairB(kTestHostB, 80); 562 HostPortPair test_host_port_pairB(kTestHostB, 80);
569 SpdySessionKey keyB( 563 SpdySessionKey keyB(
570 test_host_port_pairB, ProxyServer::Direct(), PRIVACY_MODE_DISABLED); 564 test_host_port_pairB, ProxyServer::Direct(), PRIVACY_MODE_DISABLED);
571 base::WeakPtr<SpdySession> sessionB = 565 base::WeakPtr<SpdySession> sessionB =
572 CreateInsecureSpdySession(http_session_.get(), keyB, BoundNetLog()); 566 CreateInsecureSpdySession(http_session_.get(), keyB, NetLogWithSource());
573 EXPECT_TRUE(sessionB->IsAvailable()); 567 EXPECT_TRUE(sessionB->IsAvailable());
574 568
575 GURL urlB(kTestHostB); 569 GURL urlB(kTestHostB);
576 base::WeakPtr<SpdyStream> spdy_streamB = CreateStreamSynchronously( 570 base::WeakPtr<SpdyStream> spdy_streamB = CreateStreamSynchronously(
577 SPDY_BIDIRECTIONAL_STREAM, sessionB, urlB, MEDIUM, BoundNetLog()); 571 SPDY_BIDIRECTIONAL_STREAM, sessionB, urlB, MEDIUM, NetLogWithSource());
578 test::StreamDelegateDoNothing delegateB(spdy_streamB); 572 test::StreamDelegateDoNothing delegateB(spdy_streamB);
579 spdy_streamB->SetDelegate(&delegateB); 573 spdy_streamB->SetDelegate(&delegateB);
580 574
581 // Set up session C: Draining. 575 // Set up session C: Draining.
582 StaticSocketDataProvider dataC(reads, arraysize(reads), writes, 576 StaticSocketDataProvider dataC(reads, arraysize(reads), writes,
583 arraysize(writes)); 577 arraysize(writes));
584 dataC.set_connect_data(connect_data); 578 dataC.set_connect_data(connect_data);
585 session_deps_.socket_factory->AddSocketDataProvider(&dataC); 579 session_deps_.socket_factory->AddSocketDataProvider(&dataC);
586 const std::string kTestHostC("http://www.c.com"); 580 const std::string kTestHostC("http://www.c.com");
587 HostPortPair test_host_port_pairC(kTestHostC, 80); 581 HostPortPair test_host_port_pairC(kTestHostC, 80);
588 SpdySessionKey keyC( 582 SpdySessionKey keyC(
589 test_host_port_pairC, ProxyServer::Direct(), PRIVACY_MODE_DISABLED); 583 test_host_port_pairC, ProxyServer::Direct(), PRIVACY_MODE_DISABLED);
590 base::WeakPtr<SpdySession> sessionC = 584 base::WeakPtr<SpdySession> sessionC =
591 CreateInsecureSpdySession(http_session_.get(), keyC, BoundNetLog()); 585 CreateInsecureSpdySession(http_session_.get(), keyC, NetLogWithSource());
592 586
593 sessionC->CloseSessionOnError(ERR_SPDY_PROTOCOL_ERROR, "Error!"); 587 sessionC->CloseSessionOnError(ERR_SPDY_PROTOCOL_ERROR, "Error!");
594 EXPECT_TRUE(sessionC->IsDraining()); 588 EXPECT_TRUE(sessionC->IsDraining());
595 589
596 spdy_session_pool_->OnIPAddressChanged(); 590 spdy_session_pool_->OnIPAddressChanged();
597 591
598 #if defined(OS_ANDROID) || defined(OS_WIN) || defined(OS_IOS) 592 #if defined(OS_ANDROID) || defined(OS_WIN) || defined(OS_IOS)
599 EXPECT_TRUE(sessionA->IsGoingAway()); 593 EXPECT_TRUE(sessionA->IsGoingAway());
600 EXPECT_TRUE(sessionB->IsDraining()); 594 EXPECT_TRUE(sessionB->IsDraining());
601 EXPECT_TRUE(sessionC->IsDraining()); 595 EXPECT_TRUE(sessionC->IsDraining());
(...skipping 31 matching lines...) Expand 10 before | Expand all | Expand 10 after
633 StaticSocketDataProvider data(reads, arraysize(reads), nullptr, 0); 627 StaticSocketDataProvider data(reads, arraysize(reads), nullptr, 0);
634 data.set_connect_data(MockConnect(SYNCHRONOUS, OK)); 628 data.set_connect_data(MockConnect(SYNCHRONOUS, OK));
635 session_deps_.socket_factory->AddSocketDataProvider(&data); 629 session_deps_.socket_factory->AddSocketDataProvider(&data);
636 630
637 SSLSocketDataProvider ssl(SYNCHRONOUS, OK); 631 SSLSocketDataProvider ssl(SYNCHRONOUS, OK);
638 session_deps_.socket_factory->AddSSLSocketDataProvider(&ssl); 632 session_deps_.socket_factory->AddSSLSocketDataProvider(&ssl);
639 633
640 CreateNetworkSession(); 634 CreateNetworkSession();
641 635
642 base::WeakPtr<SpdySession> session = 636 base::WeakPtr<SpdySession> session =
643 CreateInsecureSpdySession(http_session_.get(), key, BoundNetLog()); 637 CreateInsecureSpdySession(http_session_.get(), key, NetLogWithSource());
644 638
645 // Flush the SpdySession::OnReadComplete() task. 639 // Flush the SpdySession::OnReadComplete() task.
646 base::RunLoop().RunUntilIdle(); 640 base::RunLoop().RunUntilIdle();
647 641
648 EXPECT_TRUE(HasSpdySession(spdy_session_pool_, key)); 642 EXPECT_TRUE(HasSpdySession(spdy_session_pool_, key));
649 643
650 // FindAvailableSession should return |session| if called with empty |url|. 644 // FindAvailableSession should return |session| if called with empty |url|.
651 base::WeakPtr<SpdySession> session1 = 645 base::WeakPtr<SpdySession> session1 =
652 spdy_session_pool_->FindAvailableSession(key, GURL(), BoundNetLog()); 646 spdy_session_pool_->FindAvailableSession(key, GURL(), NetLogWithSource());
653 EXPECT_EQ(session.get(), session1.get()); 647 EXPECT_EQ(session.get(), session1.get());
654 648
655 // FindAvailableSession should return |session| if called with |url| for which 649 // FindAvailableSession should return |session| if called with |url| for which
656 // there is no pushed stream on any sessions owned by |spdy_session_pool_|. 650 // there is no pushed stream on any sessions owned by |spdy_session_pool_|.
657 base::WeakPtr<SpdySession> session2 = 651 base::WeakPtr<SpdySession> session2 =
658 spdy_session_pool_->FindAvailableSession( 652 spdy_session_pool_->FindAvailableSession(
659 key, GURL("http://news.example.org/foo.html"), BoundNetLog()); 653 key, GURL("http://news.example.org/foo.html"), NetLogWithSource());
660 EXPECT_EQ(session.get(), session2.get()); 654 EXPECT_EQ(session.get(), session2.get());
661 655
662 spdy_session_pool_->CloseCurrentSessions(ERR_ABORTED); 656 spdy_session_pool_->CloseCurrentSessions(ERR_ABORTED);
663 } 657 }
664 658
665 } // namespace net 659 } // namespace net
OLDNEW

Powered by Google App Engine
This is Rietveld 408576698