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