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. 4 5 #include "net/http/http_pipelined_connection_impl.h" 6 7 #include <string> 8 9 #include "base/memory/ref_counted.h" 10 #include "base/memory/scoped_ptr.h" 11 #include "base/memory/scoped_vector.h" 12 #include "net/base/capturing_net_log.h" 13 #include "net/base/io_buffer.h" 14 #include "net/base/load_timing_info.h" 15 #include "net/base/load_timing_info_test_util.h" 16 #include "net/base/net_errors.h" 17 #include "net/base/request_priority.h" 18 #include "net/http/http_pipelined_stream.h" 19 #include "net/socket/client_socket_handle.h" 20 #include "net/socket/client_socket_pool_histograms.h" 21 #include "net/socket/socket_test_util.h" 22 #include "testing/gmock/include/gmock/gmock.h" 23 #include "testing/gtest/include/gtest/gtest.h" 24 25 using testing::_; 26 using testing::NiceMock; 27 using testing::StrEq; 28 29 namespace net { 30 31 class DummySocketParams : public base::RefCounted<DummySocketParams> { 32 private: 33 friend class base::RefCounted<DummySocketParams>; 34 ~DummySocketParams() {} 35 }; 36 37 REGISTER_SOCKET_PARAMS_FOR_POOL(MockTransportClientSocketPool, 38 DummySocketParams); 39 40 namespace { 41 42 // Tests the load timing of a stream that's connected and is not the first 43 // request sent on a connection. 44 void TestLoadTimingReused(const HttpStream& stream) { 45 LoadTimingInfo load_timing_info; 46 EXPECT_TRUE(stream.GetLoadTimingInfo(&load_timing_info)); 47 48 EXPECT_TRUE(load_timing_info.socket_reused); 49 EXPECT_NE(NetLog::Source::kInvalidId, load_timing_info.socket_log_id); 50 51 ExpectConnectTimingHasNoTimes(load_timing_info.connect_timing); 52 ExpectLoadTimingHasOnlyConnectionTimes(load_timing_info); 53 } 54 55 // Tests the load timing of a stream that's connected and using a fresh 56 // connection. 57 void TestLoadTimingNotReused(const HttpStream& stream) { 58 LoadTimingInfo load_timing_info; 59 EXPECT_TRUE(stream.GetLoadTimingInfo(&load_timing_info)); 60 61 EXPECT_FALSE(load_timing_info.socket_reused); 62 EXPECT_NE(NetLog::Source::kInvalidId, load_timing_info.socket_log_id); 63 64 ExpectConnectTimingHasTimes(load_timing_info.connect_timing, 65 CONNECT_TIMING_HAS_DNS_TIMES); 66 ExpectLoadTimingHasOnlyConnectionTimes(load_timing_info); 67 } 68 69 class MockPipelineDelegate : public HttpPipelinedConnection::Delegate { 70 public: 71 MOCK_METHOD1(OnPipelineHasCapacity, void(HttpPipelinedConnection* pipeline)); 72 MOCK_METHOD2(OnPipelineFeedback, void( 73 HttpPipelinedConnection* pipeline, 74 HttpPipelinedConnection::Feedback feedback)); 75 }; 76 77 class SuddenCloseObserver : public base::MessageLoop::TaskObserver { 78 public: 79 SuddenCloseObserver(HttpStream* stream, int close_before_task) 80 : stream_(stream), 81 close_before_task_(close_before_task), 82 current_task_(0) { } 83 84 virtual void WillProcessTask(const base::PendingTask& pending_task) OVERRIDE { 85 ++current_task_; 86 if (current_task_ == close_before_task_) { 87 stream_->Close(false); 88 base::MessageLoop::current()->RemoveTaskObserver(this); 89 } 90 } 91 92 virtual void DidProcessTask(const base::PendingTask& pending_task) OVERRIDE {} 93 94 private: 95 HttpStream* stream_; 96 int close_before_task_; 97 int current_task_; 98 }; 99 100 class HttpPipelinedConnectionImplTest : public testing::Test { 101 public: 102 HttpPipelinedConnectionImplTest() 103 : histograms_("a"), 104 pool_(1, 1, &histograms_, &factory_), 105 origin_("host", 123) { 106 } 107 108 void TearDown() { 109 base::MessageLoop::current()->RunUntilIdle(); 110 } 111 112 void Initialize(MockRead* reads, size_t reads_count, 113 MockWrite* writes, size_t writes_count) { 114 data_.reset(new DeterministicSocketData(reads, reads_count, 115 writes, writes_count)); 116 data_->set_connect_data(MockConnect(SYNCHRONOUS, OK)); 117 if (reads_count || writes_count) { 118 data_->StopAfter(reads_count + writes_count); 119 } 120 factory_.AddSocketDataProvider(data_.get()); 121 scoped_refptr<DummySocketParams> params; 122 ClientSocketHandle* connection = new ClientSocketHandle; 123 // Only give the connection a real NetLog to make sure that LoadTiming uses 124 // the connection's ID, rather than the pipeline's. Since pipelines are 125 // destroyed when they've responded to all requests, but the connection 126 // lives on, this is an important behavior. 127 connection->Init("a", params, MEDIUM, CompletionCallback(), &pool_, 128 net_log_.bound()); 129 pipeline_.reset(new HttpPipelinedConnectionImpl( 130 connection, &delegate_, origin_, ssl_config_, proxy_info_, 131 BoundNetLog(), false, kProtoUnknown)); 132 } 133 134 HttpRequestInfo* GetRequestInfo(const std::string& filename) { 135 HttpRequestInfo* request_info = new HttpRequestInfo; 136 request_info->url = GURL("http://localhost/" + filename); 137 request_info->method = "GET"; 138 request_info_vector_.push_back(request_info); 139 return request_info; 140 } 141 142 HttpStream* NewTestStream(const std::string& filename) { 143 HttpStream* stream = pipeline_->CreateNewStream(); 144 HttpRequestInfo* request_info = GetRequestInfo(filename); 145 int rv = stream->InitializeStream( 146 request_info, DEFAULT_PRIORITY, BoundNetLog(), CompletionCallback()); 147 DCHECK_EQ(OK, rv); 148 return stream; 149 } 150 151 void ExpectResponse(const std::string& expected, 152 scoped_ptr<HttpStream>& stream, bool async) { 153 scoped_refptr<IOBuffer> buffer(new IOBuffer(expected.size())); 154 155 if (async) { 156 EXPECT_EQ(ERR_IO_PENDING, 157 stream->ReadResponseBody(buffer.get(), expected.size(), 158 callback_.callback())); 159 data_->RunFor(1); 160 EXPECT_EQ(static_cast<int>(expected.size()), callback_.WaitForResult()); 161 } else { 162 EXPECT_EQ(static_cast<int>(expected.size()), 163 stream->ReadResponseBody(buffer.get(), expected.size(), 164 callback_.callback())); 165 } 166 std::string actual(buffer->data(), expected.size()); 167 EXPECT_THAT(actual, StrEq(expected)); 168 } 169 170 void TestSyncRequest(scoped_ptr<HttpStream>& stream, 171 const std::string& filename) { 172 HttpRequestHeaders headers; 173 HttpResponseInfo response; 174 EXPECT_EQ(OK, stream->SendRequest(headers, &response, 175 callback_.callback())); 176 EXPECT_EQ(OK, stream->ReadResponseHeaders(callback_.callback())); 177 ExpectResponse(filename, stream, false); 178 179 stream->Close(false); 180 } 181 182 CapturingBoundNetLog net_log_; 183 DeterministicMockClientSocketFactory factory_; 184 ClientSocketPoolHistograms histograms_; 185 MockTransportClientSocketPool pool_; 186 scoped_ptr<DeterministicSocketData> data_; 187 188 HostPortPair origin_; 189 SSLConfig ssl_config_; 190 ProxyInfo proxy_info_; 191 NiceMock<MockPipelineDelegate> delegate_; 192 TestCompletionCallback callback_; 193 scoped_ptr<HttpPipelinedConnectionImpl> pipeline_; 194 ScopedVector<HttpRequestInfo> request_info_vector_; 195 }; 196 197 TEST_F(HttpPipelinedConnectionImplTest, PipelineNotUsed) { 198 Initialize(NULL, 0, NULL, 0); 199 } 200 201 TEST_F(HttpPipelinedConnectionImplTest, StreamNotUsed) { 202 Initialize(NULL, 0, NULL, 0); 203 204 scoped_ptr<HttpStream> stream(pipeline_->CreateNewStream()); 205 206 stream->Close(false); 207 } 208 209 TEST_F(HttpPipelinedConnectionImplTest, StreamBoundButNotUsed) { 210 Initialize(NULL, 0, NULL, 0); 211 212 scoped_ptr<HttpStream> stream(NewTestStream("ok.html")); 213 214 TestLoadTimingNotReused(*stream); 215 stream->Close(false); 216 TestLoadTimingNotReused(*stream); 217 } 218 219 TEST_F(HttpPipelinedConnectionImplTest, SyncSingleRequest) { 220 MockWrite writes[] = { 221 MockWrite(SYNCHRONOUS, 0, "GET /ok.html HTTP/1.1\r\n\r\n"), 222 }; 223 MockRead reads[] = { 224 MockRead(SYNCHRONOUS, 1, "HTTP/1.1 200 OK\r\n"), 225 MockRead(SYNCHRONOUS, 2, "Content-Length: 7\r\n\r\n"), 226 MockRead(SYNCHRONOUS, 3, "ok.html"), 227 }; 228 Initialize(reads, arraysize(reads), writes, arraysize(writes)); 229 230 scoped_ptr<HttpStream> stream(NewTestStream("ok.html")); 231 TestLoadTimingNotReused(*stream); 232 TestSyncRequest(stream, "ok.html"); 233 TestLoadTimingNotReused(*stream); 234 } 235 236 TEST_F(HttpPipelinedConnectionImplTest, AsyncSingleRequest) { 237 MockWrite writes[] = { 238 MockWrite(ASYNC, 0, "GET /ok.html HTTP/1.1\r\n\r\n"), 239 }; 240 MockRead reads[] = { 241 MockRead(ASYNC, 1, "HTTP/1.1 200 OK\r\n"), 242 MockRead(ASYNC, 2, "Content-Length: 7\r\n\r\n"), 243 MockRead(ASYNC, 3, "ok.html"), 244 }; 245 Initialize(reads, arraysize(reads), writes, arraysize(writes)); 246 247 scoped_ptr<HttpStream> stream(NewTestStream("ok.html")); 248 249 HttpRequestHeaders headers; 250 HttpResponseInfo response; 251 EXPECT_EQ(ERR_IO_PENDING, stream->SendRequest(headers, &response, 252 callback_.callback())); 253 data_->RunFor(1); 254 EXPECT_LE(OK, callback_.WaitForResult()); 255 TestLoadTimingNotReused(*stream); 256 257 EXPECT_EQ(ERR_IO_PENDING, stream->ReadResponseHeaders(callback_.callback())); 258 data_->RunFor(2); 259 EXPECT_LE(OK, callback_.WaitForResult()); 260 TestLoadTimingNotReused(*stream); 261 262 ExpectResponse("ok.html", stream, true); 263 TestLoadTimingNotReused(*stream); 264 265 stream->Close(false); 266 } 267 268 TEST_F(HttpPipelinedConnectionImplTest, LockStepAsyncRequests) { 269 MockWrite writes[] = { 270 MockWrite(ASYNC, 0, "GET /ok.html HTTP/1.1\r\n\r\n"), 271 MockWrite(ASYNC, 1, "GET /ko.html HTTP/1.1\r\n\r\n"), 272 }; 273 MockRead reads[] = { 274 MockRead(ASYNC, 2, "HTTP/1.1 200 OK\r\n"), 275 MockRead(ASYNC, 3, "Content-Length: 7\r\n\r\n"), 276 MockRead(ASYNC, 4, "ok.html"), 277 MockRead(ASYNC, 5, "HTTP/1.1 200 OK\r\n"), 278 MockRead(ASYNC, 6, "Content-Length: 7\r\n\r\n"), 279 MockRead(ASYNC, 7, "ko.html"), 280 }; 281 Initialize(reads, arraysize(reads), writes, arraysize(writes)); 282 283 scoped_ptr<HttpStream> stream1(NewTestStream("ok.html")); 284 scoped_ptr<HttpStream> stream2(NewTestStream("ko.html")); 285 286 HttpRequestHeaders headers1; 287 HttpResponseInfo response1; 288 EXPECT_EQ(ERR_IO_PENDING, stream1->SendRequest(headers1, &response1, 289 callback_.callback())); 290 TestLoadTimingNotReused(*stream1); 291 292 HttpRequestHeaders headers2; 293 HttpResponseInfo response2; 294 EXPECT_EQ(ERR_IO_PENDING, stream2->SendRequest(headers2, &response2, 295 callback_.callback())); 296 TestLoadTimingReused(*stream2); 297 298 data_->RunFor(1); 299 EXPECT_LE(OK, callback_.WaitForResult()); 300 data_->RunFor(1); 301 EXPECT_LE(OK, callback_.WaitForResult()); 302 303 EXPECT_EQ(ERR_IO_PENDING, stream1->ReadResponseHeaders(callback_.callback())); 304 EXPECT_EQ(ERR_IO_PENDING, stream2->ReadResponseHeaders(callback_.callback())); 305 306 data_->RunFor(2); 307 EXPECT_LE(OK, callback_.WaitForResult()); 308 309 ExpectResponse("ok.html", stream1, true); 310 311 TestLoadTimingNotReused(*stream1); 312 LoadTimingInfo load_timing_info1; 313 EXPECT_TRUE(stream1->GetLoadTimingInfo(&load_timing_info1)); 314 stream1->Close(false); 315 316 data_->RunFor(2); 317 EXPECT_LE(OK, callback_.WaitForResult()); 318 319 ExpectResponse("ko.html", stream2, true); 320 321 TestLoadTimingReused(*stream2); 322 LoadTimingInfo load_timing_info2; 323 EXPECT_TRUE(stream2->GetLoadTimingInfo(&load_timing_info2)); 324 EXPECT_EQ(load_timing_info1.socket_log_id, 325 load_timing_info2.socket_log_id); 326 stream2->Close(false); 327 } 328 329 TEST_F(HttpPipelinedConnectionImplTest, TwoResponsesInOnePacket) { 330 MockWrite writes[] = { 331 MockWrite(SYNCHRONOUS, 0, "GET /ok.html HTTP/1.1\r\n\r\n"), 332 MockWrite(SYNCHRONOUS, 1, "GET /ko.html HTTP/1.1\r\n\r\n"), 333 }; 334 MockRead reads[] = { 335 MockRead(SYNCHRONOUS, 2, 336 "HTTP/1.1 200 OK\r\n" 337 "Content-Length: 7\r\n\r\n" 338 "ok.html" 339 "HTTP/1.1 200 OK\r\n" 340 "Content-Length: 7\r\n\r\n" 341 "ko.html"), 342 }; 343 Initialize(reads, arraysize(reads), writes, arraysize(writes)); 344 345 scoped_ptr<HttpStream> stream1(NewTestStream("ok.html")); 346 scoped_ptr<HttpStream> stream2(NewTestStream("ko.html")); 347 348 HttpRequestHeaders headers1; 349 HttpResponseInfo response1; 350 EXPECT_EQ(OK, stream1->SendRequest(headers1, 351 &response1, callback_.callback())); 352 HttpRequestHeaders headers2; 353 HttpResponseInfo response2; 354 EXPECT_EQ(OK, stream2->SendRequest(headers2, 355 &response2, callback_.callback())); 356 357 EXPECT_EQ(OK, stream1->ReadResponseHeaders(callback_.callback())); 358 ExpectResponse("ok.html", stream1, false); 359 stream1->Close(false); 360 361 EXPECT_EQ(OK, stream2->ReadResponseHeaders(callback_.callback())); 362 ExpectResponse("ko.html", stream2, false); 363 stream2->Close(false); 364 } 365 366 TEST_F(HttpPipelinedConnectionImplTest, SendOrderSwapped) { 367 MockWrite writes[] = { 368 MockWrite(SYNCHRONOUS, 0, "GET /ko.html HTTP/1.1\r\n\r\n"), 369 MockWrite(SYNCHRONOUS, 4, "GET /ok.html HTTP/1.1\r\n\r\n"), 370 }; 371 MockRead reads[] = { 372 MockRead(SYNCHRONOUS, 1, "HTTP/1.1 200 OK\r\n"), 373 MockRead(SYNCHRONOUS, 2, "Content-Length: 7\r\n\r\n"), 374 MockRead(SYNCHRONOUS, 3, "ko.html"), 375 MockRead(SYNCHRONOUS, 5, "HTTP/1.1 200 OK\r\n"), 376 MockRead(SYNCHRONOUS, 6, "Content-Length: 7\r\n\r\n"), 377 MockRead(SYNCHRONOUS, 7, "ok.html"), 378 }; 379 Initialize(reads, arraysize(reads), writes, arraysize(writes)); 380 381 scoped_ptr<HttpStream> stream1(NewTestStream("ok.html")); 382 scoped_ptr<HttpStream> stream2(NewTestStream("ko.html")); 383 384 TestSyncRequest(stream2, "ko.html"); 385 TestSyncRequest(stream1, "ok.html"); 386 TestLoadTimingNotReused(*stream1); 387 TestLoadTimingReused(*stream2); 388 } 389 390 TEST_F(HttpPipelinedConnectionImplTest, ReadOrderSwapped) { 391 MockWrite writes[] = { 392 MockWrite(SYNCHRONOUS, 0, "GET /ok.html HTTP/1.1\r\n\r\n"), 393 MockWrite(SYNCHRONOUS, 1, "GET /ko.html HTTP/1.1\r\n\r\n"), 394 }; 395 MockRead reads[] = { 396 MockRead(SYNCHRONOUS, 2, "HTTP/1.1 200 OK\r\n"), 397 MockRead(SYNCHRONOUS, 3, "Content-Length: 7\r\n\r\n"), 398 MockRead(SYNCHRONOUS, 4, "ok.html"), 399 MockRead(SYNCHRONOUS, 5, "HTTP/1.1 200 OK\r\n"), 400 MockRead(SYNCHRONOUS, 6, "Content-Length: 7\r\n\r\n"), 401 MockRead(SYNCHRONOUS, 7, "ko.html"), 402 }; 403 Initialize(reads, arraysize(reads), writes, arraysize(writes)); 404 405 scoped_ptr<HttpStream> stream1(NewTestStream("ok.html")); 406 scoped_ptr<HttpStream> stream2(NewTestStream("ko.html")); 407 408 HttpRequestHeaders headers1; 409 HttpResponseInfo response1; 410 EXPECT_EQ(OK, stream1->SendRequest(headers1, 411 &response1, callback_.callback())); 412 413 HttpRequestHeaders headers2; 414 HttpResponseInfo response2; 415 EXPECT_EQ(OK, stream2->SendRequest(headers2, 416 &response2, callback_.callback())); 417 418 EXPECT_EQ(ERR_IO_PENDING, stream2->ReadResponseHeaders(callback_.callback())); 419 420 EXPECT_EQ(OK, stream1->ReadResponseHeaders(callback_.callback())); 421 ExpectResponse("ok.html", stream1, false); 422 423 stream1->Close(false); 424 425 EXPECT_LE(OK, callback_.WaitForResult()); 426 ExpectResponse("ko.html", stream2, false); 427 428 stream2->Close(false); 429 } 430 431 TEST_F(HttpPipelinedConnectionImplTest, SendWhileReading) { 432 MockWrite writes[] = { 433 MockWrite(SYNCHRONOUS, 0, "GET /ok.html HTTP/1.1\r\n\r\n"), 434 MockWrite(SYNCHRONOUS, 3, "GET /ko.html HTTP/1.1\r\n\r\n"), 435 }; 436 MockRead reads[] = { 437 MockRead(SYNCHRONOUS, 1, "HTTP/1.1 200 OK\r\n"), 438 MockRead(SYNCHRONOUS, 2, "Content-Length: 7\r\n\r\n"), 439 MockRead(SYNCHRONOUS, 4, "ok.html"), 440 MockRead(SYNCHRONOUS, 5, "HTTP/1.1 200 OK\r\n"), 441 MockRead(SYNCHRONOUS, 6, "Content-Length: 7\r\n\r\n"), 442 MockRead(SYNCHRONOUS, 7, "ko.html"), 443 }; 444 Initialize(reads, arraysize(reads), writes, arraysize(writes)); 445 446 scoped_ptr<HttpStream> stream1(NewTestStream("ok.html")); 447 scoped_ptr<HttpStream> stream2(NewTestStream("ko.html")); 448 449 HttpRequestHeaders headers1; 450 HttpResponseInfo response1; 451 EXPECT_EQ(OK, stream1->SendRequest(headers1, 452 &response1, callback_.callback())); 453 EXPECT_EQ(OK, stream1->ReadResponseHeaders(callback_.callback())); 454 455 HttpRequestHeaders headers2; 456 HttpResponseInfo response2; 457 EXPECT_EQ(OK, stream2->SendRequest(headers2, 458 &response2, callback_.callback())); 459 460 ExpectResponse("ok.html", stream1, false); 461 stream1->Close(false); 462 463 EXPECT_EQ(OK, stream2->ReadResponseHeaders(callback_.callback())); 464 ExpectResponse("ko.html", stream2, false); 465 stream2->Close(false); 466 } 467 468 TEST_F(HttpPipelinedConnectionImplTest, AsyncSendWhileAsyncReadBlocked) { 469 MockWrite writes[] = { 470 MockWrite(SYNCHRONOUS, 0, "GET /ok.html HTTP/1.1\r\n\r\n"), 471 MockWrite(ASYNC, 3, "GET /ko.html HTTP/1.1\r\n\r\n"), 472 }; 473 MockRead reads[] = { 474 MockRead(SYNCHRONOUS, 1, "HTTP/1.1 200 OK\r\n"), 475 MockRead(SYNCHRONOUS, 2, "Content-Length: 7\r\n\r\n"), 476 MockRead(ASYNC, 4, "ok.html"), 477 MockRead(SYNCHRONOUS, 5, "HTTP/1.1 200 OK\r\n"), 478 MockRead(SYNCHRONOUS, 6, "Content-Length: 7\r\n\r\n"), 479 MockRead(SYNCHRONOUS, 7, "ko.html"), 480 }; 481 Initialize(reads, arraysize(reads), writes, arraysize(writes)); 482 483 scoped_ptr<HttpStream> stream1(NewTestStream("ok.html")); 484 scoped_ptr<HttpStream> stream2(NewTestStream("ko.html")); 485 486 HttpRequestHeaders headers1; 487 HttpResponseInfo response1; 488 EXPECT_EQ(OK, stream1->SendRequest(headers1, 489 &response1, callback_.callback())); 490 EXPECT_EQ(OK, stream1->ReadResponseHeaders(callback_.callback())); 491 TestCompletionCallback callback1; 492 std::string expected = "ok.html"; 493 scoped_refptr<IOBuffer> buffer(new IOBuffer(expected.size())); 494 EXPECT_EQ(ERR_IO_PENDING, 495 stream1->ReadResponseBody(buffer.get(), expected.size(), 496 callback1.callback())); 497 498 HttpRequestHeaders headers2; 499 HttpResponseInfo response2; 500 TestCompletionCallback callback2; 501 EXPECT_EQ(ERR_IO_PENDING, stream2->SendRequest(headers2, &response2, 502 callback2.callback())); 503 504 data_->RunFor(1); 505 EXPECT_LE(OK, callback2.WaitForResult()); 506 EXPECT_EQ(ERR_IO_PENDING, stream2->ReadResponseHeaders(callback2.callback())); 507 508 data_->RunFor(1); 509 EXPECT_EQ(static_cast<int>(expected.size()), callback1.WaitForResult()); 510 std::string actual(buffer->data(), expected.size()); 511 EXPECT_THAT(actual, StrEq(expected)); 512 stream1->Close(false); 513 514 data_->StopAfter(8); 515 EXPECT_LE(OK, callback2.WaitForResult()); 516 ExpectResponse("ko.html", stream2, false); 517 stream2->Close(false); 518 } 519 520 TEST_F(HttpPipelinedConnectionImplTest, UnusedStreamAllowsLaterUse) { 521 MockWrite writes[] = { 522 MockWrite(SYNCHRONOUS, 0, "GET /ok.html HTTP/1.1\r\n\r\n"), 523 }; 524 MockRead reads[] = { 525 MockRead(SYNCHRONOUS, 1, "HTTP/1.1 200 OK\r\n"), 526 MockRead(SYNCHRONOUS, 2, "Content-Length: 7\r\n\r\n"), 527 MockRead(SYNCHRONOUS, 3, "ok.html"), 528 }; 529 Initialize(reads, arraysize(reads), writes, arraysize(writes)); 530 531 scoped_ptr<HttpStream> unused_stream(NewTestStream("unused.html")); 532 unused_stream->Close(false); 533 534 scoped_ptr<HttpStream> later_stream(NewTestStream("ok.html")); 535 TestSyncRequest(later_stream, "ok.html"); 536 } 537 538 TEST_F(HttpPipelinedConnectionImplTest, UnsentStreamAllowsLaterUse) { 539 MockWrite writes[] = { 540 MockWrite(ASYNC, 0, "GET /ok.html HTTP/1.1\r\n\r\n"), 541 MockWrite(SYNCHRONOUS, 4, "GET /ko.html HTTP/1.1\r\n\r\n"), 542 }; 543 MockRead reads[] = { 544 MockRead(ASYNC, 1, "HTTP/1.1 200 OK\r\n"), 545 MockRead(ASYNC, 2, "Content-Length: 7\r\n\r\n"), 546 MockRead(ASYNC, 3, "ok.html"), 547 MockRead(SYNCHRONOUS, 5, "HTTP/1.1 200 OK\r\n"), 548 MockRead(SYNCHRONOUS, 6, "Content-Length: 7\r\n\r\n"), 549 MockRead(SYNCHRONOUS, 7, "ko.html"), 550 }; 551 Initialize(reads, arraysize(reads), writes, arraysize(writes)); 552 553 scoped_ptr<HttpStream> stream(NewTestStream("ok.html")); 554 555 HttpRequestHeaders headers; 556 HttpResponseInfo response; 557 EXPECT_EQ(ERR_IO_PENDING, stream->SendRequest(headers, &response, 558 callback_.callback())); 559 560 scoped_ptr<HttpStream> unsent_stream(NewTestStream("unsent.html")); 561 HttpRequestHeaders unsent_headers; 562 HttpResponseInfo unsent_response; 563 EXPECT_EQ(ERR_IO_PENDING, unsent_stream->SendRequest(unsent_headers, 564 &unsent_response, 565 callback_.callback())); 566 unsent_stream->Close(false); 567 568 data_->RunFor(1); 569 EXPECT_LE(OK, callback_.WaitForResult()); 570 571 EXPECT_EQ(ERR_IO_PENDING, stream->ReadResponseHeaders(callback_.callback())); 572 data_->RunFor(2); 573 EXPECT_LE(OK, callback_.WaitForResult()); 574 575 ExpectResponse("ok.html", stream, true); 576 577 stream->Close(false); 578 579 data_->StopAfter(8); 580 scoped_ptr<HttpStream> later_stream(NewTestStream("ko.html")); 581 TestSyncRequest(later_stream, "ko.html"); 582 } 583 584 TEST_F(HttpPipelinedConnectionImplTest, FailedSend) { 585 MockWrite writes[] = { 586 MockWrite(ASYNC, ERR_FAILED), 587 }; 588 Initialize(NULL, 0, writes, arraysize(writes)); 589 590 scoped_ptr<HttpStream> failed_stream(NewTestStream("ok.html")); 591 scoped_ptr<HttpStream> evicted_stream(NewTestStream("evicted.html")); 592 scoped_ptr<HttpStream> closed_stream(NewTestStream("closed.html")); 593 scoped_ptr<HttpStream> rejected_stream(NewTestStream("rejected.html")); 594 595 HttpRequestHeaders headers; 596 HttpResponseInfo response; 597 TestCompletionCallback failed_callback; 598 EXPECT_EQ(ERR_IO_PENDING, 599 failed_stream->SendRequest(headers, &response, 600 failed_callback.callback())); 601 TestCompletionCallback evicted_callback; 602 EXPECT_EQ(ERR_IO_PENDING, 603 evicted_stream->SendRequest(headers, &response, 604 evicted_callback.callback())); 605 EXPECT_EQ(ERR_IO_PENDING, closed_stream->SendRequest(headers, &response, 606 callback_.callback())); 607 closed_stream->Close(false); 608 609 data_->RunFor(1); 610 EXPECT_EQ(ERR_FAILED, failed_callback.WaitForResult()); 611 EXPECT_EQ(ERR_PIPELINE_EVICTION, evicted_callback.WaitForResult()); 612 EXPECT_EQ(ERR_PIPELINE_EVICTION, 613 rejected_stream->SendRequest(headers, &response, 614 callback_.callback())); 615 616 failed_stream->Close(true); 617 evicted_stream->Close(true); 618 rejected_stream->Close(true); 619 } 620 621 TEST_F(HttpPipelinedConnectionImplTest, ConnectionSuddenlyClosedAfterResponse) { 622 MockWrite writes[] = { 623 MockWrite(SYNCHRONOUS, 0, "GET /ok.html HTTP/1.1\r\n\r\n"), 624 MockWrite(SYNCHRONOUS, 1, "GET /read_evicted.html HTTP/1.1\r\n\r\n"), 625 MockWrite(SYNCHRONOUS, 2, "GET /read_rejected.html HTTP/1.1\r\n\r\n"), 626 MockWrite(ASYNC, ERR_SOCKET_NOT_CONNECTED, 5), 627 }; 628 MockRead reads[] = { 629 MockRead(SYNCHRONOUS, 3, "HTTP/1.1 200 OK\r\n\r\n"), 630 MockRead(SYNCHRONOUS, 4, "ok.html"), 631 MockRead(ASYNC, OK, 6), // Connection closed message. Not read before the 632 // ERR_SOCKET_NOT_CONNECTED. 633 }; 634 Initialize(reads, arraysize(reads), writes, arraysize(writes)); 635 636 scoped_ptr<HttpStream> closed_stream(NewTestStream("ok.html")); 637 scoped_ptr<HttpStream> read_evicted_stream( 638 NewTestStream("read_evicted.html")); 639 scoped_ptr<HttpStream> read_rejected_stream( 640 NewTestStream("read_rejected.html")); 641 scoped_ptr<HttpStream> send_closed_stream( 642 NewTestStream("send_closed.html")); 643 scoped_ptr<HttpStream> send_evicted_stream( 644 NewTestStream("send_evicted.html")); 645 scoped_ptr<HttpStream> send_rejected_stream( 646 NewTestStream("send_rejected.html")); 647 648 HttpRequestHeaders headers; 649 HttpResponseInfo response; 650 EXPECT_EQ(OK, closed_stream->SendRequest(headers, 651 &response, callback_.callback())); 652 EXPECT_EQ(OK, read_evicted_stream->SendRequest(headers, &response, 653 callback_.callback())); 654 EXPECT_EQ(OK, read_rejected_stream->SendRequest(headers, &response, 655 callback_.callback())); 656 TestCompletionCallback send_closed_callback; 657 EXPECT_EQ(ERR_IO_PENDING, 658 send_closed_stream->SendRequest(headers, &response, 659 send_closed_callback.callback())); 660 TestCompletionCallback send_evicted_callback; 661 EXPECT_EQ(ERR_IO_PENDING, 662 send_evicted_stream->SendRequest(headers, &response, 663 send_evicted_callback.callback())); 664 665 TestCompletionCallback read_evicted_callback; 666 EXPECT_EQ(ERR_IO_PENDING, 667 read_evicted_stream->ReadResponseHeaders( 668 read_evicted_callback.callback())); 669 670 EXPECT_EQ(OK, closed_stream->ReadResponseHeaders(callback_.callback())); 671 ExpectResponse("ok.html", closed_stream, false); 672 closed_stream->Close(true); 673 674 EXPECT_EQ(ERR_PIPELINE_EVICTION, read_evicted_callback.WaitForResult()); 675 read_evicted_stream->Close(true); 676 677 EXPECT_EQ(ERR_PIPELINE_EVICTION, 678 read_rejected_stream->ReadResponseHeaders(callback_.callback())); 679 read_rejected_stream->Close(true); 680 681 data_->RunFor(1); 682 EXPECT_EQ(ERR_SOCKET_NOT_CONNECTED, send_closed_callback.WaitForResult()); 683 send_closed_stream->Close(true); 684 685 EXPECT_EQ(ERR_PIPELINE_EVICTION, send_evicted_callback.WaitForResult()); 686 send_evicted_stream->Close(true); 687 688 EXPECT_EQ(ERR_PIPELINE_EVICTION, 689 send_rejected_stream->SendRequest(headers, &response, 690 callback_.callback())); 691 send_rejected_stream->Close(true); 692 } 693 694 TEST_F(HttpPipelinedConnectionImplTest, AbortWhileSending) { 695 MockWrite writes[] = { 696 MockWrite(ASYNC, 0, "GET /aborts.html HTTP/1.1\r\n\r\n"), 697 }; 698 Initialize(NULL, 0, writes, arraysize(writes)); 699 700 scoped_ptr<HttpStream> aborted_stream(NewTestStream("aborts.html")); 701 scoped_ptr<HttpStream> evicted_stream(NewTestStream("evicted.html")); 702 703 HttpRequestHeaders headers; 704 HttpResponseInfo response; 705 TestCompletionCallback aborted_callback; 706 EXPECT_EQ(ERR_IO_PENDING, 707 aborted_stream->SendRequest(headers, &response, 708 aborted_callback.callback())); 709 TestCompletionCallback evicted_callback; 710 EXPECT_EQ(ERR_IO_PENDING, 711 evicted_stream->SendRequest(headers, &response, 712 evicted_callback.callback())); 713 714 aborted_stream->Close(true); 715 EXPECT_EQ(ERR_PIPELINE_EVICTION, evicted_callback.WaitForResult()); 716 evicted_stream->Close(true); 717 EXPECT_FALSE(aborted_callback.have_result()); 718 } 719 720 TEST_F(HttpPipelinedConnectionImplTest, AbortWhileSendingSecondRequest) { 721 MockWrite writes[] = { 722 MockWrite(ASYNC, 0, "GET /ok.html HTTP/1.1\r\n\r\n"), 723 MockWrite(ASYNC, 1, "GET /aborts.html HTTP/1.1\r\n\r\n"), 724 }; 725 Initialize(NULL, 0, writes, arraysize(writes)); 726 727 scoped_ptr<HttpStream> ok_stream(NewTestStream("ok.html")); 728 scoped_ptr<HttpStream> aborted_stream(NewTestStream("aborts.html")); 729 scoped_ptr<HttpStream> evicted_stream(NewTestStream("evicted.html")); 730 731 HttpRequestHeaders headers; 732 HttpResponseInfo response; 733 TestCompletionCallback ok_callback; 734 EXPECT_EQ(ERR_IO_PENDING, ok_stream->SendRequest(headers, &response, 735 ok_callback.callback())); 736 TestCompletionCallback aborted_callback; 737 EXPECT_EQ(ERR_IO_PENDING, 738 aborted_stream->SendRequest(headers, &response, 739 aborted_callback.callback())); 740 TestCompletionCallback evicted_callback; 741 EXPECT_EQ(ERR_IO_PENDING, 742 evicted_stream->SendRequest(headers, &response, 743 evicted_callback.callback())); 744 745 data_->RunFor(1); 746 EXPECT_LE(OK, ok_callback.WaitForResult()); 747 base::MessageLoop::current()->RunUntilIdle(); 748 aborted_stream->Close(true); 749 EXPECT_EQ(ERR_PIPELINE_EVICTION, evicted_callback.WaitForResult()); 750 evicted_stream->Close(true); 751 EXPECT_FALSE(aborted_callback.have_result()); 752 ok_stream->Close(true); 753 } 754 755 TEST_F(HttpPipelinedConnectionImplTest, AbortWhileReadingHeaders) { 756 MockWrite writes[] = { 757 MockWrite(SYNCHRONOUS, 0, "GET /aborts.html HTTP/1.1\r\n\r\n"), 758 MockWrite(SYNCHRONOUS, 1, "GET /evicted.html HTTP/1.1\r\n\r\n"), 759 }; 760 MockRead reads[] = { 761 MockRead(ASYNC, ERR_FAILED, 2), 762 }; 763 Initialize(reads, arraysize(reads), writes, arraysize(writes)); 764 765 scoped_ptr<HttpStream> aborted_stream(NewTestStream("aborts.html")); 766 scoped_ptr<HttpStream> evicted_stream(NewTestStream("evicted.html")); 767 scoped_ptr<HttpStream> rejected_stream(NewTestStream("rejected.html")); 768 769 HttpRequestHeaders headers; 770 HttpResponseInfo response; 771 EXPECT_EQ(OK, 772 aborted_stream->SendRequest(headers, &response, 773 callback_.callback())); 774 EXPECT_EQ(OK, 775 evicted_stream->SendRequest(headers, &response, 776 callback_.callback())); 777 778 EXPECT_EQ(ERR_IO_PENDING, 779 aborted_stream->ReadResponseHeaders(callback_.callback())); 780 TestCompletionCallback evicted_callback; 781 EXPECT_EQ(ERR_IO_PENDING, 782 evicted_stream->ReadResponseHeaders(evicted_callback.callback())); 783 784 aborted_stream->Close(true); 785 EXPECT_EQ(ERR_PIPELINE_EVICTION, evicted_callback.WaitForResult()); 786 evicted_stream->Close(true); 787 788 EXPECT_EQ(ERR_PIPELINE_EVICTION, 789 rejected_stream->SendRequest(headers, &response, 790 callback_.callback())); 791 rejected_stream->Close(true); 792 } 793 794 TEST_F(HttpPipelinedConnectionImplTest, PendingResponseAbandoned) { 795 MockWrite writes[] = { 796 MockWrite(SYNCHRONOUS, 0, "GET /ok.html HTTP/1.1\r\n\r\n"), 797 MockWrite(SYNCHRONOUS, 1, "GET /abandoned.html HTTP/1.1\r\n\r\n"), 798 MockWrite(SYNCHRONOUS, 2, "GET /evicted.html HTTP/1.1\r\n\r\n"), 799 }; 800 MockRead reads[] = { 801 MockRead(SYNCHRONOUS, 3, "HTTP/1.1 200 OK\r\n"), 802 MockRead(SYNCHRONOUS, 4, "Content-Length: 7\r\n\r\n"), 803 MockRead(SYNCHRONOUS, 5, "ok.html"), 804 }; 805 Initialize(reads, arraysize(reads), writes, arraysize(writes)); 806 807 scoped_ptr<HttpStream> ok_stream(NewTestStream("ok.html")); 808 scoped_ptr<HttpStream> abandoned_stream(NewTestStream("abandoned.html")); 809 scoped_ptr<HttpStream> evicted_stream(NewTestStream("evicted.html")); 810 811 HttpRequestHeaders headers; 812 HttpResponseInfo response; 813 EXPECT_EQ(OK, ok_stream->SendRequest(headers, &response, 814 callback_.callback())); 815 EXPECT_EQ(OK, abandoned_stream->SendRequest(headers, &response, 816 callback_.callback())); 817 EXPECT_EQ(OK, evicted_stream->SendRequest(headers, &response, 818 callback_.callback())); 819 820 EXPECT_EQ(OK, ok_stream->ReadResponseHeaders(callback_.callback())); 821 TestCompletionCallback abandoned_callback; 822 EXPECT_EQ(ERR_IO_PENDING, abandoned_stream->ReadResponseHeaders( 823 abandoned_callback.callback())); 824 TestCompletionCallback evicted_callback; 825 EXPECT_EQ(ERR_IO_PENDING, 826 evicted_stream->ReadResponseHeaders(evicted_callback.callback())); 827 828 abandoned_stream->Close(false); 829 830 ExpectResponse("ok.html", ok_stream, false); 831 ok_stream->Close(false); 832 833 EXPECT_EQ(ERR_PIPELINE_EVICTION, evicted_callback.WaitForResult()); 834 evicted_stream->Close(true); 835 EXPECT_FALSE(evicted_stream->IsConnectionReusable()); 836 } 837 838 TEST_F(HttpPipelinedConnectionImplTest, DisconnectedAfterOneRequestRecovery) { 839 MockWrite writes[] = { 840 MockWrite(SYNCHRONOUS, 0, "GET /ok.html HTTP/1.1\r\n\r\n"), 841 MockWrite(SYNCHRONOUS, 1, "GET /rejected.html HTTP/1.1\r\n\r\n"), 842 MockWrite(ASYNC, ERR_SOCKET_NOT_CONNECTED, 5), 843 MockWrite(SYNCHRONOUS, ERR_SOCKET_NOT_CONNECTED, 7), 844 }; 845 MockRead reads[] = { 846 MockRead(SYNCHRONOUS, 2, "HTTP/1.1 200 OK\r\n"), 847 MockRead(SYNCHRONOUS, 3, "Content-Length: 7\r\n\r\n"), 848 MockRead(SYNCHRONOUS, 4, "ok.html"), 849 MockRead(SYNCHRONOUS, ERR_SOCKET_NOT_CONNECTED, 6), 850 }; 851 Initialize(reads, arraysize(reads), writes, arraysize(writes)); 852 853 scoped_ptr<HttpStream> ok_stream(NewTestStream("ok.html")); 854 scoped_ptr<HttpStream> rejected_read_stream(NewTestStream("rejected.html")); 855 scoped_ptr<HttpStream> evicted_send_stream(NewTestStream("evicted.html")); 856 scoped_ptr<HttpStream> rejected_send_stream(NewTestStream("rejected.html")); 857 858 HttpRequestHeaders headers; 859 HttpResponseInfo response; 860 EXPECT_EQ(OK, ok_stream->SendRequest(headers, 861 &response, callback_.callback())); 862 EXPECT_EQ(OK, rejected_read_stream->SendRequest(headers, &response, 863 callback_.callback())); 864 865 EXPECT_EQ(OK, ok_stream->ReadResponseHeaders(callback_.callback())); 866 ExpectResponse("ok.html", ok_stream, false); 867 ok_stream->Close(false); 868 869 TestCompletionCallback read_callback; 870 EXPECT_EQ(ERR_IO_PENDING, 871 evicted_send_stream->SendRequest(headers, &response, 872 read_callback.callback())); 873 data_->RunFor(1); 874 EXPECT_EQ(ERR_PIPELINE_EVICTION, read_callback.WaitForResult()); 875 876 EXPECT_EQ(ERR_PIPELINE_EVICTION, 877 rejected_read_stream->ReadResponseHeaders(callback_.callback())); 878 EXPECT_EQ(ERR_PIPELINE_EVICTION, 879 rejected_send_stream->SendRequest(headers, &response, 880 callback_.callback())); 881 882 rejected_read_stream->Close(true); 883 rejected_send_stream->Close(true); 884 } 885 886 TEST_F(HttpPipelinedConnectionImplTest, DisconnectedPendingReadRecovery) { 887 MockWrite writes[] = { 888 MockWrite(SYNCHRONOUS, 0, "GET /ok.html HTTP/1.1\r\n\r\n"), 889 MockWrite(SYNCHRONOUS, 1, "GET /evicted.html HTTP/1.1\r\n\r\n"), 890 }; 891 MockRead reads[] = { 892 MockRead(SYNCHRONOUS, 2, "HTTP/1.1 200 OK\r\n"), 893 MockRead(SYNCHRONOUS, 3, "Content-Length: 7\r\n\r\n"), 894 MockRead(SYNCHRONOUS, 4, "ok.html"), 895 MockRead(SYNCHRONOUS, ERR_SOCKET_NOT_CONNECTED, 5), 896 }; 897 Initialize(reads, arraysize(reads), writes, arraysize(writes)); 898 899 scoped_ptr<HttpStream> ok_stream(NewTestStream("ok.html")); 900 scoped_ptr<HttpStream> evicted_stream(NewTestStream("evicted.html")); 901 902 HttpRequestHeaders headers; 903 HttpResponseInfo response; 904 EXPECT_EQ(OK, ok_stream->SendRequest(headers, 905 &response, callback_.callback())); 906 EXPECT_EQ(OK, evicted_stream->SendRequest(headers, &response, 907 callback_.callback())); 908 909 EXPECT_EQ(OK, ok_stream->ReadResponseHeaders(callback_.callback())); 910 ExpectResponse("ok.html", ok_stream, false); 911 912 TestCompletionCallback evicted_callback; 913 EXPECT_EQ(ERR_IO_PENDING, 914 evicted_stream->ReadResponseHeaders(evicted_callback.callback())); 915 916 ok_stream->Close(false); 917 918 EXPECT_EQ(ERR_PIPELINE_EVICTION, evicted_callback.WaitForResult()); 919 evicted_stream->Close(false); 920 } 921 922 TEST_F(HttpPipelinedConnectionImplTest, CloseCalledBeforeNextReadLoop) { 923 MockWrite writes[] = { 924 MockWrite(SYNCHRONOUS, 0, "GET /ok.html HTTP/1.1\r\n\r\n"), 925 MockWrite(SYNCHRONOUS, 1, "GET /evicted.html HTTP/1.1\r\n\r\n"), 926 }; 927 MockRead reads[] = { 928 MockRead(SYNCHRONOUS, 2, "HTTP/1.1 200 OK\r\n"), 929 MockRead(SYNCHRONOUS, 3, "Content-Length: 7\r\n\r\n"), 930 MockRead(SYNCHRONOUS, 4, "ok.html"), 931 MockRead(SYNCHRONOUS, ERR_SOCKET_NOT_CONNECTED, 5), 932 }; 933 Initialize(reads, arraysize(reads), writes, arraysize(writes)); 934 935 scoped_ptr<HttpStream> ok_stream(NewTestStream("ok.html")); 936 scoped_ptr<HttpStream> evicted_stream(NewTestStream("evicted.html")); 937 938 HttpRequestHeaders headers; 939 HttpResponseInfo response; 940 EXPECT_EQ(OK, ok_stream->SendRequest(headers, 941 &response, callback_.callback())); 942 EXPECT_EQ(OK, evicted_stream->SendRequest(headers, &response, 943 callback_.callback())); 944 945 EXPECT_EQ(OK, ok_stream->ReadResponseHeaders(callback_.callback())); 946 ExpectResponse("ok.html", ok_stream, false); 947 948 TestCompletionCallback evicted_callback; 949 EXPECT_EQ(ERR_IO_PENDING, 950 evicted_stream->ReadResponseHeaders(evicted_callback.callback())); 951 952 ok_stream->Close(false); 953 evicted_stream->Close(false); 954 } 955 956 TEST_F(HttpPipelinedConnectionImplTest, CloseCalledBeforeReadCallback) { 957 MockWrite writes[] = { 958 MockWrite(SYNCHRONOUS, 0, "GET /ok.html HTTP/1.1\r\n\r\n"), 959 MockWrite(SYNCHRONOUS, 1, "GET /evicted.html HTTP/1.1\r\n\r\n"), 960 }; 961 MockRead reads[] = { 962 MockRead(SYNCHRONOUS, 2, "HTTP/1.1 200 OK\r\n"), 963 MockRead(SYNCHRONOUS, 3, "Content-Length: 7\r\n\r\n"), 964 MockRead(SYNCHRONOUS, 4, "ok.html"), 965 MockRead(SYNCHRONOUS, ERR_SOCKET_NOT_CONNECTED, 5), 966 }; 967 Initialize(reads, arraysize(reads), writes, arraysize(writes)); 968 969 scoped_ptr<HttpStream> ok_stream(NewTestStream("ok.html")); 970 scoped_ptr<HttpStream> evicted_stream(NewTestStream("evicted.html")); 971 972 HttpRequestHeaders headers; 973 HttpResponseInfo response; 974 EXPECT_EQ(OK, ok_stream->SendRequest(headers, 975 &response, callback_.callback())); 976 EXPECT_EQ(OK, evicted_stream->SendRequest(headers, &response, 977 callback_.callback())); 978 979 EXPECT_EQ(OK, ok_stream->ReadResponseHeaders(callback_.callback())); 980 ExpectResponse("ok.html", ok_stream, false); 981 982 TestCompletionCallback evicted_callback; 983 EXPECT_EQ(ERR_IO_PENDING, 984 evicted_stream->ReadResponseHeaders(evicted_callback.callback())); 985 986 ok_stream->Close(false); 987 988 // The posted tasks should be: 989 // 1. DoReadHeadersLoop, which will post: 990 // 2. InvokeUserCallback 991 SuddenCloseObserver observer(evicted_stream.get(), 2); 992 base::MessageLoop::current()->AddTaskObserver(&observer); 993 base::MessageLoop::current()->RunUntilIdle(); 994 EXPECT_FALSE(evicted_callback.have_result()); 995 } 996 997 class StreamDeleter { 998 public: 999 StreamDeleter(HttpStream* stream) 1000 : stream_(stream), 1001 callback_(base::Bind(&StreamDeleter::OnIOComplete, 1002 base::Unretained(this))) { 1003 } 1004 1005 ~StreamDeleter() { 1006 EXPECT_FALSE(stream_); 1007 } 1008 1009 const CompletionCallback& callback() { return callback_; } 1010 1011 private: 1012 void OnIOComplete(int result) { 1013 stream_->Close(true); 1014 stream_.reset(); 1015 } 1016 1017 scoped_ptr<HttpStream> stream_; 1018 CompletionCallback callback_; 1019 }; 1020 1021 TEST_F(HttpPipelinedConnectionImplTest, CloseCalledDuringSendCallback) { 1022 MockWrite writes[] = { 1023 MockWrite(ASYNC, 0, "GET /ok.html HTTP/1.1\r\n\r\n"), 1024 }; 1025 Initialize(NULL, 0, writes, arraysize(writes)); 1026 1027 HttpStream* stream(NewTestStream("ok.html")); 1028 1029 StreamDeleter deleter(stream); 1030 HttpRequestHeaders headers; 1031 HttpResponseInfo response; 1032 EXPECT_EQ(ERR_IO_PENDING, stream->SendRequest(headers, &response, 1033 deleter.callback())); 1034 data_->RunFor(1); 1035 } 1036 1037 TEST_F(HttpPipelinedConnectionImplTest, CloseCalledDuringReadCallback) { 1038 MockWrite writes[] = { 1039 MockWrite(SYNCHRONOUS, 0, "GET /ok.html HTTP/1.1\r\n\r\n"), 1040 }; 1041 MockRead reads[] = { 1042 MockRead(SYNCHRONOUS, 1, "HTTP/1.1 200 OK\r\n"), 1043 MockRead(ASYNC, 2, "Content-Length: 7\r\n\r\n"), 1044 }; 1045 Initialize(reads, arraysize(reads), writes, arraysize(writes)); 1046 1047 HttpStream* stream(NewTestStream("ok.html")); 1048 1049 HttpRequestHeaders headers; 1050 HttpResponseInfo response; 1051 EXPECT_EQ(OK, stream->SendRequest(headers, 1052 &response, callback_.callback())); 1053 1054 StreamDeleter deleter(stream); 1055 EXPECT_EQ(ERR_IO_PENDING, stream->ReadResponseHeaders(deleter.callback())); 1056 data_->RunFor(1); 1057 } 1058 1059 TEST_F(HttpPipelinedConnectionImplTest, 1060 CloseCalledDuringReadCallbackWithPendingRead) { 1061 MockWrite writes[] = { 1062 MockWrite(SYNCHRONOUS, 0, "GET /failed.html HTTP/1.1\r\n\r\n"), 1063 MockWrite(SYNCHRONOUS, 1, "GET /evicted.html HTTP/1.1\r\n\r\n"), 1064 }; 1065 MockRead reads[] = { 1066 MockRead(SYNCHRONOUS, 2, "HTTP/1.1 200 OK\r\n"), 1067 MockRead(ASYNC, 3, "Content-Length: 7\r\n\r\n"), 1068 }; 1069 Initialize(reads, arraysize(reads), writes, arraysize(writes)); 1070 1071 HttpStream* failed_stream(NewTestStream("failed.html")); 1072 HttpStream* evicted_stream(NewTestStream("evicted.html")); 1073 1074 HttpRequestHeaders headers; 1075 HttpResponseInfo response; 1076 EXPECT_EQ(OK, failed_stream->SendRequest(headers, &response, 1077 callback_.callback())); 1078 EXPECT_EQ(OK, evicted_stream->SendRequest(headers, &response, 1079 callback_.callback())); 1080 1081 StreamDeleter failed_deleter(failed_stream); 1082 EXPECT_EQ(ERR_IO_PENDING, 1083 failed_stream->ReadResponseHeaders(failed_deleter.callback())); 1084 StreamDeleter evicted_deleter(evicted_stream); 1085 EXPECT_EQ(ERR_IO_PENDING, 1086 evicted_stream->ReadResponseHeaders(evicted_deleter.callback())); 1087 data_->RunFor(1); 1088 } 1089 1090 TEST_F(HttpPipelinedConnectionImplTest, CloseOtherDuringReadCallback) { 1091 MockWrite writes[] = { 1092 MockWrite(SYNCHRONOUS, 0, "GET /deleter.html HTTP/1.1\r\n\r\n"), 1093 MockWrite(SYNCHRONOUS, 1, "GET /deleted.html HTTP/1.1\r\n\r\n"), 1094 }; 1095 MockRead reads[] = { 1096 MockRead(SYNCHRONOUS, 2, "HTTP/1.1 200 OK\r\n"), 1097 MockRead(ASYNC, 3, "Content-Length: 7\r\n\r\n"), 1098 }; 1099 Initialize(reads, arraysize(reads), writes, arraysize(writes)); 1100 1101 scoped_ptr<HttpStream> deleter_stream(NewTestStream("deleter.html")); 1102 HttpStream* deleted_stream(NewTestStream("deleted.html")); 1103 1104 HttpRequestHeaders headers; 1105 HttpResponseInfo response; 1106 EXPECT_EQ(OK, deleter_stream->SendRequest(headers, 1107 &response, callback_.callback())); 1108 EXPECT_EQ(OK, deleted_stream->SendRequest(headers, 1109 &response, callback_.callback())); 1110 1111 StreamDeleter deleter(deleted_stream); 1112 EXPECT_EQ(ERR_IO_PENDING, 1113 deleter_stream->ReadResponseHeaders(deleter.callback())); 1114 EXPECT_EQ(ERR_IO_PENDING, 1115 deleted_stream->ReadResponseHeaders(callback_.callback())); 1116 data_->RunFor(1); 1117 } 1118 1119 TEST_F(HttpPipelinedConnectionImplTest, CloseBeforeSendCallbackRuns) { 1120 MockWrite writes[] = { 1121 MockWrite(ASYNC, 0, "GET /close.html HTTP/1.1\r\n\r\n"), 1122 MockWrite(ASYNC, 1, "GET /dummy.html HTTP/1.1\r\n\r\n"), 1123 }; 1124 Initialize(NULL, 0, writes, arraysize(writes)); 1125 1126 scoped_ptr<HttpStream> close_stream(NewTestStream("close.html")); 1127 scoped_ptr<HttpStream> dummy_stream(NewTestStream("dummy.html")); 1128 1129 scoped_ptr<TestCompletionCallback> close_callback( 1130 new TestCompletionCallback); 1131 HttpRequestHeaders headers; 1132 HttpResponseInfo response; 1133 EXPECT_EQ(ERR_IO_PENDING, 1134 close_stream->SendRequest(headers, 1135 &response, close_callback->callback())); 1136 1137 data_->RunFor(1); 1138 EXPECT_FALSE(close_callback->have_result()); 1139 1140 close_stream->Close(false); 1141 close_stream.reset(); 1142 close_callback.reset(); 1143 1144 base::MessageLoop::current()->RunUntilIdle(); 1145 } 1146 1147 TEST_F(HttpPipelinedConnectionImplTest, CloseBeforeReadCallbackRuns) { 1148 MockWrite writes[] = { 1149 MockWrite(SYNCHRONOUS, 0, "GET /close.html HTTP/1.1\r\n\r\n"), 1150 MockWrite(SYNCHRONOUS, 3, "GET /dummy.html HTTP/1.1\r\n\r\n"), 1151 }; 1152 MockRead reads[] = { 1153 MockRead(SYNCHRONOUS, 1, "HTTP/1.1 200 OK\r\n"), 1154 MockRead(ASYNC, 2, "Content-Length: 7\r\n\r\n"), 1155 }; 1156 Initialize(reads, arraysize(reads), writes, arraysize(writes)); 1157 1158 scoped_ptr<HttpStream> close_stream(NewTestStream("close.html")); 1159 scoped_ptr<HttpStream> dummy_stream(NewTestStream("dummy.html")); 1160 1161 HttpRequestHeaders headers; 1162 HttpResponseInfo response; 1163 EXPECT_EQ(OK, close_stream->SendRequest(headers, 1164 &response, callback_.callback())); 1165 1166 scoped_ptr<TestCompletionCallback> close_callback( 1167 new TestCompletionCallback); 1168 EXPECT_EQ(ERR_IO_PENDING, 1169 close_stream->ReadResponseHeaders(close_callback->callback())); 1170 1171 data_->RunFor(1); 1172 EXPECT_FALSE(close_callback->have_result()); 1173 1174 close_stream->Close(false); 1175 close_stream.reset(); 1176 close_callback.reset(); 1177 1178 base::MessageLoop::current()->RunUntilIdle(); 1179 } 1180 1181 TEST_F(HttpPipelinedConnectionImplTest, AbortWhileSendQueued) { 1182 MockWrite writes[] = { 1183 MockWrite(ASYNC, 0, "GET /ok.html HTTP/1.1\r\n\r\n"), 1184 MockWrite(ASYNC, 1, "GET /ko.html HTTP/1.1\r\n\r\n"), 1185 }; 1186 Initialize(NULL, 0, writes, arraysize(writes)); 1187 1188 scoped_ptr<HttpStream> stream1(NewTestStream("ok.html")); 1189 scoped_ptr<HttpStream> stream2(NewTestStream("ko.html")); 1190 1191 HttpRequestHeaders headers1; 1192 HttpResponseInfo response1; 1193 TestCompletionCallback callback1; 1194 EXPECT_EQ(ERR_IO_PENDING, stream1->SendRequest(headers1, &response1, 1195 callback1.callback())); 1196 1197 HttpRequestHeaders headers2; 1198 HttpResponseInfo response2; 1199 TestCompletionCallback callback2; 1200 EXPECT_EQ(ERR_IO_PENDING, stream2->SendRequest(headers2, &response2, 1201 callback2.callback())); 1202 1203 stream2.reset(); 1204 stream1->Close(true); 1205 1206 EXPECT_FALSE(callback2.have_result()); 1207 } 1208 1209 TEST_F(HttpPipelinedConnectionImplTest, NoGapBetweenCloseAndEviction) { 1210 MockWrite writes[] = { 1211 MockWrite(SYNCHRONOUS, 0, "GET /close.html HTTP/1.1\r\n\r\n"), 1212 MockWrite(SYNCHRONOUS, 2, "GET /dummy.html HTTP/1.1\r\n\r\n"), 1213 }; 1214 MockRead reads[] = { 1215 MockRead(SYNCHRONOUS, 1, "HTTP/1.1 200 OK\r\n"), 1216 MockRead(ASYNC, 3, "Content-Length: 7\r\n\r\n"), 1217 }; 1218 Initialize(reads, arraysize(reads), writes, arraysize(writes)); 1219 1220 scoped_ptr<HttpStream> close_stream(NewTestStream("close.html")); 1221 scoped_ptr<HttpStream> dummy_stream(NewTestStream("dummy.html")); 1222 1223 HttpRequestHeaders headers; 1224 HttpResponseInfo response; 1225 EXPECT_EQ(OK, close_stream->SendRequest(headers, &response, 1226 callback_.callback())); 1227 1228 TestCompletionCallback close_callback; 1229 EXPECT_EQ(ERR_IO_PENDING, 1230 close_stream->ReadResponseHeaders(close_callback.callback())); 1231 1232 EXPECT_EQ(OK, dummy_stream->SendRequest(headers, &response, 1233 callback_.callback())); 1234 1235 TestCompletionCallback dummy_callback; 1236 EXPECT_EQ(ERR_IO_PENDING, 1237 dummy_stream->ReadResponseHeaders(dummy_callback.callback())); 1238 1239 close_stream->Close(true); 1240 close_stream.reset(); 1241 1242 EXPECT_TRUE(dummy_callback.have_result()); 1243 EXPECT_EQ(ERR_PIPELINE_EVICTION, dummy_callback.WaitForResult()); 1244 dummy_stream->Close(true); 1245 dummy_stream.reset(); 1246 pipeline_.reset(); 1247 } 1248 1249 TEST_F(HttpPipelinedConnectionImplTest, RecoverFromDrainOnRedirect) { 1250 MockWrite writes[] = { 1251 MockWrite(SYNCHRONOUS, 0, "GET /redirect.html HTTP/1.1\r\n\r\n"), 1252 MockWrite(SYNCHRONOUS, 1, "GET /ok.html HTTP/1.1\r\n\r\n"), 1253 }; 1254 MockRead reads[] = { 1255 MockRead(SYNCHRONOUS, 2, 1256 "HTTP/1.1 302 OK\r\n" 1257 "Content-Length: 8\r\n\r\n" 1258 "redirect"), 1259 MockRead(SYNCHRONOUS, 3, 1260 "HTTP/1.1 200 OK\r\n" 1261 "Content-Length: 7\r\n\r\n" 1262 "ok.html"), 1263 }; 1264 Initialize(reads, arraysize(reads), writes, arraysize(writes)); 1265 1266 scoped_ptr<HttpStream> stream1(NewTestStream("redirect.html")); 1267 scoped_ptr<HttpStream> stream2(NewTestStream("ok.html")); 1268 1269 HttpRequestHeaders headers1; 1270 HttpResponseInfo response1; 1271 EXPECT_EQ(OK, stream1->SendRequest(headers1, 1272 &response1, callback_.callback())); 1273 HttpRequestHeaders headers2; 1274 HttpResponseInfo response2; 1275 EXPECT_EQ(OK, stream2->SendRequest(headers2, 1276 &response2, callback_.callback())); 1277 1278 EXPECT_EQ(OK, stream1->ReadResponseHeaders(callback_.callback())); 1279 stream1.release()->Drain(NULL); 1280 1281 EXPECT_EQ(OK, stream2->ReadResponseHeaders(callback_.callback())); 1282 ExpectResponse("ok.html", stream2, false); 1283 stream2->Close(false); 1284 } 1285 1286 TEST_F(HttpPipelinedConnectionImplTest, EvictAfterDrainOfUnknownSize) { 1287 MockWrite writes[] = { 1288 MockWrite(SYNCHRONOUS, 0, "GET /redirect.html HTTP/1.1\r\n\r\n"), 1289 MockWrite(SYNCHRONOUS, 1, "GET /ok.html HTTP/1.1\r\n\r\n"), 1290 }; 1291 MockRead reads[] = { 1292 MockRead(SYNCHRONOUS, 2, 1293 "HTTP/1.1 302 OK\r\n\r\n" 1294 "redirect"), 1295 }; 1296 Initialize(reads, arraysize(reads), writes, arraysize(writes)); 1297 1298 scoped_ptr<HttpStream> stream1(NewTestStream("redirect.html")); 1299 scoped_ptr<HttpStream> stream2(NewTestStream("ok.html")); 1300 1301 HttpRequestHeaders headers1; 1302 HttpResponseInfo response1; 1303 EXPECT_EQ(OK, stream1->SendRequest(headers1, 1304 &response1, callback_.callback())); 1305 HttpRequestHeaders headers2; 1306 HttpResponseInfo response2; 1307 EXPECT_EQ(OK, stream2->SendRequest(headers2, 1308 &response2, callback_.callback())); 1309 1310 EXPECT_EQ(OK, stream1->ReadResponseHeaders(callback_.callback())); 1311 stream1.release()->Drain(NULL); 1312 1313 EXPECT_EQ(ERR_PIPELINE_EVICTION, 1314 stream2->ReadResponseHeaders(callback_.callback())); 1315 stream2->Close(false); 1316 } 1317 1318 TEST_F(HttpPipelinedConnectionImplTest, EvictAfterFailedDrain) { 1319 MockWrite writes[] = { 1320 MockWrite(SYNCHRONOUS, 0, "GET /redirect.html HTTP/1.1\r\n\r\n"), 1321 MockWrite(SYNCHRONOUS, 1, "GET /ok.html HTTP/1.1\r\n\r\n"), 1322 }; 1323 MockRead reads[] = { 1324 MockRead(SYNCHRONOUS, 2, 1325 "HTTP/1.1 302 OK\r\n" 1326 "Content-Length: 8\r\n\r\n"), 1327 MockRead(SYNCHRONOUS, ERR_SOCKET_NOT_CONNECTED, 3), 1328 }; 1329 Initialize(reads, arraysize(reads), writes, arraysize(writes)); 1330 1331 scoped_ptr<HttpStream> stream1(NewTestStream("redirect.html")); 1332 scoped_ptr<HttpStream> stream2(NewTestStream("ok.html")); 1333 1334 HttpRequestHeaders headers1; 1335 HttpResponseInfo response1; 1336 EXPECT_EQ(OK, stream1->SendRequest(headers1, 1337 &response1, callback_.callback())); 1338 HttpRequestHeaders headers2; 1339 HttpResponseInfo response2; 1340 EXPECT_EQ(OK, stream2->SendRequest(headers2, 1341 &response2, callback_.callback())); 1342 1343 1344 EXPECT_EQ(OK, stream1->ReadResponseHeaders(callback_.callback())); 1345 stream1.release()->Drain(NULL); 1346 1347 EXPECT_EQ(ERR_PIPELINE_EVICTION, 1348 stream2->ReadResponseHeaders(callback_.callback())); 1349 stream2->Close(false); 1350 } 1351 1352 TEST_F(HttpPipelinedConnectionImplTest, EvictIfDrainingChunkedEncoding) { 1353 MockWrite writes[] = { 1354 MockWrite(SYNCHRONOUS, 0, "GET /redirect.html HTTP/1.1\r\n\r\n"), 1355 MockWrite(SYNCHRONOUS, 1, "GET /ok.html HTTP/1.1\r\n\r\n"), 1356 }; 1357 MockRead reads[] = { 1358 MockRead(SYNCHRONOUS, 2, 1359 "HTTP/1.1 302 OK\r\n" 1360 "Transfer-Encoding: chunked\r\n\r\n"), 1361 MockRead(SYNCHRONOUS, 3, 1362 "jibberish"), 1363 }; 1364 Initialize(reads, arraysize(reads), writes, arraysize(writes)); 1365 1366 scoped_ptr<HttpStream> stream1(NewTestStream("redirect.html")); 1367 scoped_ptr<HttpStream> stream2(NewTestStream("ok.html")); 1368 1369 HttpRequestHeaders headers1; 1370 HttpResponseInfo response1; 1371 EXPECT_EQ(OK, stream1->SendRequest(headers1, 1372 &response1, callback_.callback())); 1373 HttpRequestHeaders headers2; 1374 HttpResponseInfo response2; 1375 EXPECT_EQ(OK, stream2->SendRequest(headers2, 1376 &response2, callback_.callback())); 1377 1378 1379 EXPECT_EQ(OK, stream1->ReadResponseHeaders(callback_.callback())); 1380 stream1.release()->Drain(NULL); 1381 1382 EXPECT_EQ(ERR_PIPELINE_EVICTION, 1383 stream2->ReadResponseHeaders(callback_.callback())); 1384 stream2->Close(false); 1385 } 1386 1387 TEST_F(HttpPipelinedConnectionImplTest, EvictionDueToMissingContentLength) { 1388 MockWrite writes[] = { 1389 MockWrite(SYNCHRONOUS, 0, "GET /ok.html HTTP/1.1\r\n\r\n"), 1390 MockWrite(SYNCHRONOUS, 1, "GET /evicted.html HTTP/1.1\r\n\r\n"), 1391 MockWrite(SYNCHRONOUS, 2, "GET /rejected.html HTTP/1.1\r\n\r\n"), 1392 }; 1393 MockRead reads[] = { 1394 MockRead(ASYNC, 3, "HTTP/1.1 200 OK\r\n\r\n"), 1395 MockRead(SYNCHRONOUS, 4, "ok.html"), 1396 MockRead(SYNCHRONOUS, OK, 5), 1397 }; 1398 Initialize(reads, arraysize(reads), writes, arraysize(writes)); 1399 1400 scoped_ptr<HttpStream> ok_stream(NewTestStream("ok.html")); 1401 scoped_ptr<HttpStream> evicted_stream(NewTestStream("evicted.html")); 1402 scoped_ptr<HttpStream> rejected_stream(NewTestStream("rejected.html")); 1403 1404 HttpRequestHeaders headers; 1405 HttpResponseInfo response; 1406 EXPECT_EQ(OK, ok_stream->SendRequest(headers, 1407 &response, callback_.callback())); 1408 EXPECT_EQ(OK, evicted_stream->SendRequest(headers, 1409 &response, callback_.callback())); 1410 EXPECT_EQ(OK, rejected_stream->SendRequest(headers, 1411 &response, callback_.callback())); 1412 1413 TestCompletionCallback ok_callback; 1414 EXPECT_EQ(ERR_IO_PENDING, 1415 ok_stream->ReadResponseHeaders(ok_callback.callback())); 1416 1417 TestCompletionCallback evicted_callback; 1418 EXPECT_EQ(ERR_IO_PENDING, 1419 evicted_stream->ReadResponseHeaders(evicted_callback.callback())); 1420 1421 data_->RunFor(1); 1422 EXPECT_LE(OK, ok_callback.WaitForResult()); 1423 data_->StopAfter(10); 1424 1425 ExpectResponse("ok.html", ok_stream, false); 1426 ok_stream->Close(false); 1427 1428 EXPECT_EQ(ERR_PIPELINE_EVICTION, 1429 rejected_stream->ReadResponseHeaders(callback_.callback())); 1430 rejected_stream->Close(true); 1431 EXPECT_EQ(ERR_PIPELINE_EVICTION, evicted_callback.WaitForResult()); 1432 evicted_stream->Close(true); 1433 } 1434 1435 TEST_F(HttpPipelinedConnectionImplTest, FeedbackOnSocketError) { 1436 MockWrite writes[] = { 1437 MockWrite(SYNCHRONOUS, 0, "GET /ok.html HTTP/1.1\r\n\r\n"), 1438 }; 1439 MockRead reads[] = { 1440 MockRead(SYNCHRONOUS, ERR_FAILED, 1), 1441 }; 1442 Initialize(reads, arraysize(reads), writes, arraysize(writes)); 1443 1444 EXPECT_CALL(delegate_, 1445 OnPipelineFeedback( 1446 pipeline_.get(), 1447 HttpPipelinedConnection::PIPELINE_SOCKET_ERROR)) 1448 .Times(1); 1449 1450 scoped_ptr<HttpStream> stream(NewTestStream("ok.html")); 1451 HttpRequestHeaders headers; 1452 HttpResponseInfo response; 1453 EXPECT_EQ(OK, stream->SendRequest(headers, 1454 &response, callback_.callback())); 1455 EXPECT_EQ(ERR_FAILED, stream->ReadResponseHeaders(callback_.callback())); 1456 } 1457 1458 TEST_F(HttpPipelinedConnectionImplTest, FeedbackOnNoInternetConnection) { 1459 MockWrite writes[] = { 1460 MockWrite(SYNCHRONOUS, 0, "GET /ok.html HTTP/1.1\r\n\r\n"), 1461 }; 1462 MockRead reads[] = { 1463 MockRead(SYNCHRONOUS, ERR_INTERNET_DISCONNECTED, 1), 1464 }; 1465 Initialize(reads, arraysize(reads), writes, arraysize(writes)); 1466 1467 EXPECT_CALL(delegate_, OnPipelineFeedback(_, _)) 1468 .Times(0); 1469 1470 scoped_ptr<HttpStream> stream(NewTestStream("ok.html")); 1471 HttpRequestHeaders headers; 1472 HttpResponseInfo response; 1473 EXPECT_EQ(OK, stream->SendRequest(headers, 1474 &response, callback_.callback())); 1475 EXPECT_EQ(ERR_INTERNET_DISCONNECTED, 1476 stream->ReadResponseHeaders(callback_.callback())); 1477 } 1478 1479 TEST_F(HttpPipelinedConnectionImplTest, FeedbackOnHttp10) { 1480 MockWrite writes[] = { 1481 MockWrite(SYNCHRONOUS, 0, "GET /ok.html HTTP/1.1\r\n\r\n"), 1482 }; 1483 MockRead reads[] = { 1484 MockRead(SYNCHRONOUS, 1, "HTTP/1.0 200 OK\r\n"), 1485 MockRead(SYNCHRONOUS, 2, "Content-Length: 7\r\n"), 1486 MockRead(SYNCHRONOUS, 3, "Connection: keep-alive\r\n\r\n"), 1487 MockRead(SYNCHRONOUS, 4, "ok.html"), 1488 }; 1489 Initialize(reads, arraysize(reads), writes, arraysize(writes)); 1490 1491 EXPECT_CALL(delegate_, 1492 OnPipelineFeedback(pipeline_.get(), 1493 HttpPipelinedConnection::OLD_HTTP_VERSION)) 1494 .Times(1); 1495 1496 scoped_ptr<HttpStream> stream(NewTestStream("ok.html")); 1497 TestSyncRequest(stream, "ok.html"); 1498 } 1499 1500 TEST_F(HttpPipelinedConnectionImplTest, FeedbackOnMustClose) { 1501 MockWrite writes[] = { 1502 MockWrite(SYNCHRONOUS, 0, "GET /ok.html HTTP/1.1\r\n\r\n"), 1503 }; 1504 MockRead reads[] = { 1505 MockRead(SYNCHRONOUS, 1, "HTTP/1.1 200 OK\r\n"), 1506 MockRead(SYNCHRONOUS, 2, "Content-Length: 7\r\n"), 1507 MockRead(SYNCHRONOUS, 3, "Connection: close\r\n\r\n"), 1508 MockRead(SYNCHRONOUS, 4, "ok.html"), 1509 }; 1510 Initialize(reads, arraysize(reads), writes, arraysize(writes)); 1511 1512 EXPECT_CALL(delegate_, 1513 OnPipelineFeedback( 1514 pipeline_.get(), 1515 HttpPipelinedConnection::MUST_CLOSE_CONNECTION)) 1516 .Times(1); 1517 1518 scoped_ptr<HttpStream> stream(NewTestStream("ok.html")); 1519 TestSyncRequest(stream, "ok.html"); 1520 } 1521 1522 TEST_F(HttpPipelinedConnectionImplTest, FeedbackOnNoContentLength) { 1523 MockWrite writes[] = { 1524 MockWrite(SYNCHRONOUS, 0, "GET /ok.html HTTP/1.1\r\n\r\n"), 1525 }; 1526 MockRead reads[] = { 1527 MockRead(SYNCHRONOUS, 1, "HTTP/1.1 200 OK\r\n\r\n"), 1528 MockRead(SYNCHRONOUS, 2, "ok.html"), 1529 }; 1530 Initialize(reads, arraysize(reads), writes, arraysize(writes)); 1531 1532 EXPECT_CALL(delegate_, 1533 OnPipelineFeedback( 1534 pipeline_.get(), 1535 HttpPipelinedConnection::MUST_CLOSE_CONNECTION)) 1536 .Times(1); 1537 1538 scoped_ptr<HttpStream> stream(NewTestStream("ok.html")); 1539 TestSyncRequest(stream, "ok.html"); 1540 } 1541 1542 TEST_F(HttpPipelinedConnectionImplTest, FeedbackOnAuthenticationRequired) { 1543 MockWrite writes[] = { 1544 MockWrite(SYNCHRONOUS, 0, "GET /ok.html HTTP/1.1\r\n\r\n"), 1545 }; 1546 MockRead reads[] = { 1547 MockRead(SYNCHRONOUS, 1, "HTTP/1.1 401 Unauthorized\r\n"), 1548 MockRead(SYNCHRONOUS, 2, "WWW-Authenticate: NTLM\r\n"), 1549 MockRead(SYNCHRONOUS, 3, "Content-Length: 7\r\n\r\n"), 1550 MockRead(SYNCHRONOUS, 4, "ok.html"), 1551 }; 1552 Initialize(reads, arraysize(reads), writes, arraysize(writes)); 1553 1554 EXPECT_CALL(delegate_, 1555 OnPipelineFeedback( 1556 pipeline_.get(), 1557 HttpPipelinedConnection::AUTHENTICATION_REQUIRED)) 1558 .Times(1); 1559 1560 scoped_ptr<HttpStream> stream(NewTestStream("ok.html")); 1561 TestSyncRequest(stream, "ok.html"); 1562 } 1563 1564 TEST_F(HttpPipelinedConnectionImplTest, OnPipelineHasCapacity) { 1565 MockWrite writes[] = { 1566 MockWrite(SYNCHRONOUS, 0, "GET /ok.html HTTP/1.1\r\n\r\n"), 1567 }; 1568 Initialize(NULL, 0, writes, arraysize(writes)); 1569 1570 EXPECT_CALL(delegate_, OnPipelineHasCapacity(pipeline_.get())).Times(0); 1571 scoped_ptr<HttpStream> stream(NewTestStream("ok.html")); 1572 1573 EXPECT_CALL(delegate_, OnPipelineHasCapacity(pipeline_.get())).Times(1); 1574 HttpRequestHeaders headers; 1575 HttpResponseInfo response; 1576 EXPECT_EQ(OK, stream->SendRequest(headers, 1577 &response, callback_.callback())); 1578 1579 EXPECT_CALL(delegate_, OnPipelineHasCapacity(pipeline_.get())).Times(0); 1580 base::MessageLoop::current()->RunUntilIdle(); 1581 1582 stream->Close(false); 1583 EXPECT_CALL(delegate_, OnPipelineHasCapacity(pipeline_.get())).Times(1); 1584 stream.reset(NULL); 1585 } 1586 1587 TEST_F(HttpPipelinedConnectionImplTest, OnPipelineHasCapacityWithoutSend) { 1588 MockWrite writes[] = { 1589 MockWrite(SYNCHRONOUS, 0, "GET /ok.html HTTP/1.1\r\n\r\n"), 1590 }; 1591 Initialize(NULL, 0, writes, arraysize(writes)); 1592 1593 EXPECT_CALL(delegate_, OnPipelineHasCapacity(pipeline_.get())).Times(0); 1594 scoped_ptr<HttpStream> stream(NewTestStream("ok.html")); 1595 1596 EXPECT_CALL(delegate_, OnPipelineHasCapacity(pipeline_.get())).Times(1); 1597 base::MessageLoop::current()->RunUntilIdle(); 1598 1599 stream->Close(false); 1600 EXPECT_CALL(delegate_, OnPipelineHasCapacity(pipeline_.get())).Times(1); 1601 stream.reset(NULL); 1602 } 1603 1604 } // anonymous namespace 1605 1606 } // namespace net 1607
