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/quic/quic_http_stream.h" 6 7 #include <vector> 8 9 #include "net/base/net_errors.h" 10 #include "net/base/test_completion_callback.h" 11 #include "net/base/upload_bytes_element_reader.h" 12 #include "net/base/upload_data_stream.h" 13 #include "net/http/http_response_headers.h" 14 #include "net/http/transport_security_state.h" 15 #include "net/quic/congestion_control/receive_algorithm_interface.h" 16 #include "net/quic/congestion_control/send_algorithm_interface.h" 17 #include "net/quic/crypto/crypto_protocol.h" 18 #include "net/quic/crypto/quic_decrypter.h" 19 #include "net/quic/crypto/quic_encrypter.h" 20 #include "net/quic/crypto/quic_server_info.h" 21 #include "net/quic/quic_client_session.h" 22 #include "net/quic/quic_connection.h" 23 #include "net/quic/quic_connection_helper.h" 24 #include "net/quic/quic_default_packet_writer.h" 25 #include "net/quic/quic_http_utils.h" 26 #include "net/quic/quic_reliable_client_stream.h" 27 #include "net/quic/quic_write_blocked_list.h" 28 #include "net/quic/spdy_utils.h" 29 #include "net/quic/test_tools/mock_clock.h" 30 #include "net/quic/test_tools/mock_crypto_client_stream_factory.h" 31 #include "net/quic/test_tools/mock_random.h" 32 #include "net/quic/test_tools/quic_connection_peer.h" 33 #include "net/quic/test_tools/quic_test_packet_maker.h" 34 #include "net/quic/test_tools/quic_test_utils.h" 35 #include "net/quic/test_tools/test_task_runner.h" 36 #include "net/socket/socket_test_util.h" 37 #include "net/spdy/spdy_frame_builder.h" 38 #include "net/spdy/spdy_framer.h" 39 #include "net/spdy/spdy_http_utils.h" 40 #include "net/spdy/spdy_protocol.h" 41 #include "testing/gmock/include/gmock/gmock.h" 42 #include "testing/gtest/include/gtest/gtest.h" 43 44 using testing::_; 45 using testing::AnyNumber; 46 using testing::Return; 47 48 namespace net { 49 namespace test { 50 namespace { 51 52 const char kUploadData[] = "Really nifty data!"; 53 const char kServerHostname[] = "www.google.com"; 54 const uint16 kServerPort = 80; 55 56 class TestQuicConnection : public QuicConnection { 57 public: 58 TestQuicConnection(const QuicVersionVector& versions, 59 QuicConnectionId connection_id, 60 IPEndPoint address, 61 QuicConnectionHelper* helper, 62 const QuicConnection::PacketWriterFactory& writer_factory) 63 : QuicConnection(connection_id, 64 address, 65 helper, 66 writer_factory, 67 true /* owns_writer */, 68 false /* is_server */, 69 versions) { 70 } 71 72 void SetSendAlgorithm(SendAlgorithmInterface* send_algorithm) { 73 QuicConnectionPeer::SetSendAlgorithm(this, send_algorithm); 74 } 75 76 void SetReceiveAlgorithm(ReceiveAlgorithmInterface* receive_algorithm) { 77 QuicConnectionPeer::SetReceiveAlgorithm(this, receive_algorithm); 78 } 79 }; 80 81 class TestReceiveAlgorithm : public ReceiveAlgorithmInterface { 82 public: 83 virtual bool GenerateCongestionFeedback( 84 QuicCongestionFeedbackFrame* /*congestion_feedback*/) { 85 return false; 86 } 87 88 MOCK_METHOD3(RecordIncomingPacket, 89 void(QuicByteCount, QuicPacketSequenceNumber, QuicTime)); 90 }; 91 92 // Subclass of QuicHttpStream that closes itself when the first piece of data 93 // is received. 94 class AutoClosingStream : public QuicHttpStream { 95 public: 96 explicit AutoClosingStream(const base::WeakPtr<QuicClientSession>& session) 97 : QuicHttpStream(session) { 98 } 99 100 virtual int OnDataReceived(const char* data, int length) OVERRIDE { 101 Close(false); 102 return OK; 103 } 104 }; 105 106 class TestPacketWriterFactory : public QuicConnection::PacketWriterFactory { 107 public: 108 explicit TestPacketWriterFactory(DatagramClientSocket* socket) 109 : socket_(socket) {} 110 virtual ~TestPacketWriterFactory() {} 111 112 virtual QuicPacketWriter* Create(QuicConnection* connection) const OVERRIDE { 113 return new QuicDefaultPacketWriter(socket_); 114 } 115 116 private: 117 DatagramClientSocket* socket_; 118 }; 119 120 } // namespace 121 122 class QuicHttpStreamPeer { 123 public: 124 static QuicReliableClientStream* GetQuicReliableClientStream( 125 QuicHttpStream* stream) { 126 return stream->stream_; 127 } 128 }; 129 130 class QuicHttpStreamTest : public ::testing::TestWithParam<QuicVersion> { 131 protected: 132 static const bool kFin = true; 133 static const bool kIncludeVersion = true; 134 static const bool kIncludeCongestionFeedback = true; 135 136 // Holds a packet to be written to the wire, and the IO mode that should 137 // be used by the mock socket when performing the write. 138 struct PacketToWrite { 139 PacketToWrite(IoMode mode, QuicEncryptedPacket* packet) 140 : mode(mode), 141 packet(packet) { 142 } 143 IoMode mode; 144 QuicEncryptedPacket* packet; 145 }; 146 147 QuicHttpStreamTest() 148 : net_log_(BoundNetLog()), 149 use_closing_stream_(false), 150 read_buffer_(new IOBufferWithSize(4096)), 151 connection_id_(2), 152 stream_id_(kClientDataStreamId1), 153 maker_(GetParam(), connection_id_, &clock_), 154 random_generator_(0) { 155 IPAddressNumber ip; 156 CHECK(ParseIPLiteralToNumber("192.0.2.33", &ip)); 157 peer_addr_ = IPEndPoint(ip, 443); 158 self_addr_ = IPEndPoint(ip, 8435); 159 clock_.AdvanceTime(QuicTime::Delta::FromMilliseconds(20)); 160 } 161 162 ~QuicHttpStreamTest() { 163 session_->CloseSessionOnError(ERR_ABORTED); 164 for (size_t i = 0; i < writes_.size(); i++) { 165 delete writes_[i].packet; 166 } 167 } 168 169 // Adds a packet to the list of expected writes. 170 void AddWrite(scoped_ptr<QuicEncryptedPacket> packet) { 171 writes_.push_back(PacketToWrite(SYNCHRONOUS, packet.release())); 172 } 173 174 // Returns the packet to be written at position |pos|. 175 QuicEncryptedPacket* GetWrite(size_t pos) { 176 return writes_[pos].packet; 177 } 178 179 bool AtEof() { 180 return socket_data_->at_read_eof() && socket_data_->at_write_eof(); 181 } 182 183 void ProcessPacket(scoped_ptr<QuicEncryptedPacket> packet) { 184 connection_->ProcessUdpPacket(self_addr_, peer_addr_, *packet); 185 } 186 187 // Configures the test fixture to use the list of expected writes. 188 void Initialize() { 189 mock_writes_.reset(new MockWrite[writes_.size()]); 190 for (size_t i = 0; i < writes_.size(); i++) { 191 mock_writes_[i] = MockWrite(writes_[i].mode, 192 writes_[i].packet->data(), 193 writes_[i].packet->length()); 194 }; 195 196 socket_data_.reset(new StaticSocketDataProvider(NULL, 0, mock_writes_.get(), 197 writes_.size())); 198 199 MockUDPClientSocket* socket = new MockUDPClientSocket(socket_data_.get(), 200 net_log_.net_log()); 201 socket->Connect(peer_addr_); 202 runner_ = new TestTaskRunner(&clock_); 203 send_algorithm_ = new MockSendAlgorithm(); 204 receive_algorithm_ = new TestReceiveAlgorithm(); 205 EXPECT_CALL(*receive_algorithm_, RecordIncomingPacket(_, _, _)). 206 Times(AnyNumber()); 207 EXPECT_CALL(*send_algorithm_, 208 OnPacketSent(_, _, _, _, _)).WillRepeatedly(Return(true)); 209 EXPECT_CALL(*send_algorithm_, RetransmissionDelay()).WillRepeatedly( 210 Return(QuicTime::Delta::Zero())); 211 EXPECT_CALL(*send_algorithm_, GetCongestionWindow()).WillRepeatedly( 212 Return(kMaxPacketSize)); 213 EXPECT_CALL(*send_algorithm_, TimeUntilSend(_, _, _)). 214 WillRepeatedly(Return(QuicTime::Delta::Zero())); 215 EXPECT_CALL(*send_algorithm_, BandwidthEstimate()).WillRepeatedly( 216 Return(QuicBandwidth::Zero())); 217 EXPECT_CALL(*send_algorithm_, SetFromConfig(_, _)).Times(AnyNumber()); 218 helper_.reset(new QuicConnectionHelper(runner_.get(), &clock_, 219 &random_generator_)); 220 TestPacketWriterFactory writer_factory(socket); 221 connection_ = new TestQuicConnection(SupportedVersions(GetParam()), 222 connection_id_, peer_addr_, 223 helper_.get(), writer_factory); 224 connection_->set_visitor(&visitor_); 225 connection_->SetSendAlgorithm(send_algorithm_); 226 connection_->SetReceiveAlgorithm(receive_algorithm_); 227 crypto_config_.SetDefaults(); 228 session_.reset( 229 new QuicClientSession(connection_, 230 scoped_ptr<DatagramClientSocket>(socket), 231 NULL, 232 &transport_security_state_, 233 make_scoped_ptr((QuicServerInfo*)NULL), 234 DefaultQuicConfig(), 235 base::MessageLoop::current()-> 236 message_loop_proxy().get(), 237 NULL)); 238 session_->InitializeSession(QuicServerId(kServerHostname, kServerPort, 239 false, PRIVACY_MODE_DISABLED), 240 &crypto_config_, 241 &crypto_client_stream_factory_); 242 session_->GetCryptoStream()->CryptoConnect(); 243 EXPECT_TRUE(session_->IsCryptoHandshakeConfirmed()); 244 stream_.reset(use_closing_stream_ ? 245 new AutoClosingStream(session_->GetWeakPtr()) : 246 new QuicHttpStream(session_->GetWeakPtr())); 247 } 248 249 void SetRequest(const std::string& method, 250 const std::string& path, 251 RequestPriority priority) { 252 request_headers_ = maker_.GetRequestHeaders(method, "http", path); 253 } 254 255 void SetResponse(const std::string& status, const std::string& body) { 256 response_headers_ = maker_.GetResponseHeaders(status); 257 response_data_ = body; 258 } 259 260 scoped_ptr<QuicEncryptedPacket> ConstructDataPacket( 261 QuicPacketSequenceNumber sequence_number, 262 bool should_include_version, 263 bool fin, 264 QuicStreamOffset offset, 265 base::StringPiece data) { 266 return maker_.MakeDataPacket( 267 sequence_number, stream_id_, should_include_version, fin, offset, data); 268 } 269 270 scoped_ptr<QuicEncryptedPacket> ConstructRequestHeadersPacket( 271 QuicPacketSequenceNumber sequence_number, 272 bool fin) { 273 return maker_.MakeRequestHeadersPacket( 274 sequence_number, stream_id_, kIncludeVersion, fin, request_headers_); 275 } 276 277 scoped_ptr<QuicEncryptedPacket> ConstructResponseHeadersPacket( 278 QuicPacketSequenceNumber sequence_number, 279 bool fin) { 280 return maker_.MakeResponseHeadersPacket( 281 sequence_number, stream_id_, !kIncludeVersion, fin, response_headers_); 282 } 283 284 scoped_ptr<QuicEncryptedPacket> ConstructRstStreamPacket( 285 QuicPacketSequenceNumber sequence_number) { 286 return maker_.MakeRstPacket( 287 sequence_number, true, stream_id_, 288 AdjustErrorForVersion(QUIC_RST_FLOW_CONTROL_ACCOUNTING, GetParam())); 289 } 290 291 scoped_ptr<QuicEncryptedPacket> ConstructAckAndRstStreamPacket( 292 QuicPacketSequenceNumber sequence_number) { 293 return maker_.MakeAckAndRstPacket( 294 sequence_number, !kIncludeVersion, stream_id_, QUIC_STREAM_CANCELLED, 295 2, 1, !kIncludeCongestionFeedback); 296 } 297 298 scoped_ptr<QuicEncryptedPacket> ConstructAckPacket( 299 QuicPacketSequenceNumber sequence_number, 300 QuicPacketSequenceNumber largest_received, 301 QuicPacketSequenceNumber least_unacked) { 302 return maker_.MakeAckPacket(sequence_number, largest_received, 303 least_unacked, !kIncludeCongestionFeedback); 304 } 305 306 BoundNetLog net_log_; 307 bool use_closing_stream_; 308 MockSendAlgorithm* send_algorithm_; 309 TestReceiveAlgorithm* receive_algorithm_; 310 scoped_refptr<TestTaskRunner> runner_; 311 scoped_ptr<MockWrite[]> mock_writes_; 312 MockClock clock_; 313 TestQuicConnection* connection_; 314 scoped_ptr<QuicConnectionHelper> helper_; 315 testing::StrictMock<MockConnectionVisitor> visitor_; 316 scoped_ptr<QuicHttpStream> stream_; 317 TransportSecurityState transport_security_state_; 318 scoped_ptr<QuicClientSession> session_; 319 QuicCryptoClientConfig crypto_config_; 320 TestCompletionCallback callback_; 321 HttpRequestInfo request_; 322 HttpRequestHeaders headers_; 323 HttpResponseInfo response_; 324 scoped_refptr<IOBufferWithSize> read_buffer_; 325 SpdyHeaderBlock request_headers_; 326 SpdyHeaderBlock response_headers_; 327 std::string request_data_; 328 std::string response_data_; 329 330 private: 331 const QuicConnectionId connection_id_; 332 const QuicStreamId stream_id_; 333 QuicTestPacketMaker maker_; 334 IPEndPoint self_addr_; 335 IPEndPoint peer_addr_; 336 MockRandom random_generator_; 337 MockCryptoClientStreamFactory crypto_client_stream_factory_; 338 scoped_ptr<StaticSocketDataProvider> socket_data_; 339 std::vector<PacketToWrite> writes_; 340 }; 341 342 INSTANTIATE_TEST_CASE_P(Version, QuicHttpStreamTest, 343 ::testing::ValuesIn(QuicSupportedVersions())); 344 345 TEST_P(QuicHttpStreamTest, RenewStreamForAuth) { 346 Initialize(); 347 EXPECT_EQ(NULL, stream_->RenewStreamForAuth()); 348 } 349 350 TEST_P(QuicHttpStreamTest, CanFindEndOfResponse) { 351 Initialize(); 352 EXPECT_TRUE(stream_->CanFindEndOfResponse()); 353 } 354 355 TEST_P(QuicHttpStreamTest, IsConnectionReusable) { 356 Initialize(); 357 EXPECT_FALSE(stream_->IsConnectionReusable()); 358 } 359 360 TEST_P(QuicHttpStreamTest, GetRequest) { 361 SetRequest("GET", "/", DEFAULT_PRIORITY); 362 AddWrite(ConstructRequestHeadersPacket(1, kFin)); 363 Initialize(); 364 365 request_.method = "GET"; 366 request_.url = GURL("http://www.google.com/"); 367 368 EXPECT_EQ(OK, stream_->InitializeStream(&request_, DEFAULT_PRIORITY, 369 net_log_, callback_.callback())); 370 EXPECT_EQ(OK, stream_->SendRequest(headers_, &response_, 371 callback_.callback())); 372 373 // Ack the request. 374 ProcessPacket(ConstructAckPacket(1, 0, 0)); 375 376 EXPECT_EQ(ERR_IO_PENDING, 377 stream_->ReadResponseHeaders(callback_.callback())); 378 379 SetResponse("404 Not Found", std::string()); 380 ProcessPacket(ConstructResponseHeadersPacket(2, kFin)); 381 382 // Now that the headers have been processed, the callback will return. 383 EXPECT_EQ(OK, callback_.WaitForResult()); 384 ASSERT_TRUE(response_.headers.get()); 385 EXPECT_EQ(404, response_.headers->response_code()); 386 EXPECT_TRUE(response_.headers->HasHeaderValue("Content-Type", "text/plain")); 387 EXPECT_FALSE(response_.response_time.is_null()); 388 EXPECT_FALSE(response_.request_time.is_null()); 389 390 // There is no body, so this should return immediately. 391 EXPECT_EQ(0, stream_->ReadResponseBody(read_buffer_.get(), 392 read_buffer_->size(), 393 callback_.callback())); 394 EXPECT_TRUE(stream_->IsResponseBodyComplete()); 395 EXPECT_TRUE(AtEof()); 396 } 397 398 // Regression test for http://crbug.com/288128 399 TEST_P(QuicHttpStreamTest, GetRequestLargeResponse) { 400 SetRequest("GET", "/", DEFAULT_PRIORITY); 401 AddWrite(ConstructRequestHeadersPacket(1, kFin)); 402 Initialize(); 403 404 request_.method = "GET"; 405 request_.url = GURL("http://www.google.com/"); 406 407 EXPECT_EQ(OK, stream_->InitializeStream(&request_, DEFAULT_PRIORITY, 408 net_log_, callback_.callback())); 409 EXPECT_EQ(OK, stream_->SendRequest(headers_, &response_, 410 callback_.callback())); 411 412 // Ack the request. 413 ProcessPacket(ConstructAckPacket(1, 0, 0)); 414 415 EXPECT_EQ(ERR_IO_PENDING, 416 stream_->ReadResponseHeaders(callback_.callback())); 417 418 SpdyHeaderBlock headers; 419 headers[":status"] = "200 OK"; 420 headers[":version"] = "HTTP/1.1"; 421 headers["content-type"] = "text/plain"; 422 headers["big6"] = std::string(10000, 'x'); // Lots of x's. 423 424 std::string response = SpdyUtils::SerializeUncompressedHeaders(headers); 425 EXPECT_LT(4096u, response.length()); 426 stream_->OnDataReceived(response.data(), response.length()); 427 stream_->OnClose(QUIC_NO_ERROR); 428 429 // Now that the headers have been processed, the callback will return. 430 EXPECT_EQ(OK, callback_.WaitForResult()); 431 ASSERT_TRUE(response_.headers.get()); 432 EXPECT_EQ(200, response_.headers->response_code()); 433 EXPECT_TRUE(response_.headers->HasHeaderValue("Content-Type", "text/plain")); 434 435 // There is no body, so this should return immediately. 436 EXPECT_EQ(0, stream_->ReadResponseBody(read_buffer_.get(), 437 read_buffer_->size(), 438 callback_.callback())); 439 EXPECT_TRUE(stream_->IsResponseBodyComplete()); 440 EXPECT_TRUE(AtEof()); 441 } 442 443 // Regression test for http://crbug.com/409101 444 TEST_P(QuicHttpStreamTest, SessionClosedBeforeSendRequest) { 445 SetRequest("GET", "/", DEFAULT_PRIORITY); 446 Initialize(); 447 448 request_.method = "GET"; 449 request_.url = GURL("http://www.google.com/"); 450 451 EXPECT_EQ(OK, stream_->InitializeStream(&request_, DEFAULT_PRIORITY, 452 net_log_, callback_.callback())); 453 454 session_->connection()->CloseConnection(QUIC_NO_ERROR, true); 455 456 EXPECT_EQ(ERR_CONNECTION_CLOSED, 457 stream_->SendRequest(headers_, &response_, 458 callback_.callback())); 459 } 460 461 // Regression test for http://crbug.com/409871 462 TEST_P(QuicHttpStreamTest, SessionClosedBeforeReadResponseHeaders) { 463 SetRequest("GET", "/", DEFAULT_PRIORITY); 464 AddWrite(ConstructRequestHeadersPacket(1, kFin)); 465 Initialize(); 466 467 request_.method = "GET"; 468 request_.url = GURL("http://www.google.com/"); 469 470 EXPECT_EQ(OK, stream_->InitializeStream(&request_, DEFAULT_PRIORITY, 471 net_log_, callback_.callback())); 472 473 EXPECT_EQ(OK, stream_->SendRequest(headers_, &response_, 474 callback_.callback())); 475 476 session_->connection()->CloseConnection(QUIC_NO_ERROR, true); 477 478 EXPECT_NE(OK, stream_->ReadResponseHeaders(callback_.callback())); 479 } 480 481 TEST_P(QuicHttpStreamTest, SendPostRequest) { 482 SetRequest("POST", "/", DEFAULT_PRIORITY); 483 AddWrite(ConstructRequestHeadersPacket(1, !kFin)); 484 AddWrite(ConstructDataPacket(2, kIncludeVersion, kFin, 0, kUploadData)); 485 AddWrite(ConstructAckPacket(3, 3, 1)); 486 487 Initialize(); 488 489 ScopedVector<UploadElementReader> element_readers; 490 element_readers.push_back( 491 new UploadBytesElementReader(kUploadData, strlen(kUploadData))); 492 UploadDataStream upload_data_stream(element_readers.Pass(), 0); 493 request_.method = "POST"; 494 request_.url = GURL("http://www.google.com/"); 495 request_.upload_data_stream = &upload_data_stream; 496 ASSERT_EQ(OK, request_.upload_data_stream->Init(CompletionCallback())); 497 498 EXPECT_EQ(OK, stream_->InitializeStream(&request_, DEFAULT_PRIORITY, 499 net_log_, callback_.callback())); 500 EXPECT_EQ(OK, stream_->SendRequest(headers_, &response_, 501 callback_.callback())); 502 503 // Ack both packets in the request. 504 ProcessPacket(ConstructAckPacket(1, 0, 0)); 505 506 // Send the response headers (but not the body). 507 SetResponse("200 OK", std::string()); 508 ProcessPacket(ConstructResponseHeadersPacket(2, !kFin)); 509 510 // Since the headers have already arrived, this should return immediately. 511 EXPECT_EQ(OK, stream_->ReadResponseHeaders(callback_.callback())); 512 ASSERT_TRUE(response_.headers.get()); 513 EXPECT_EQ(200, response_.headers->response_code()); 514 EXPECT_TRUE(response_.headers->HasHeaderValue("Content-Type", "text/plain")); 515 516 // Send the response body. 517 const char kResponseBody[] = "Hello world!"; 518 ProcessPacket(ConstructDataPacket(3, false, kFin, 0, kResponseBody)); 519 // Since the body has already arrived, this should return immediately. 520 EXPECT_EQ(static_cast<int>(strlen(kResponseBody)), 521 stream_->ReadResponseBody(read_buffer_.get(), read_buffer_->size(), 522 callback_.callback())); 523 524 EXPECT_TRUE(stream_->IsResponseBodyComplete()); 525 EXPECT_TRUE(AtEof()); 526 } 527 528 TEST_P(QuicHttpStreamTest, SendChunkedPostRequest) { 529 SetRequest("POST", "/", DEFAULT_PRIORITY); 530 size_t chunk_size = strlen(kUploadData); 531 AddWrite(ConstructRequestHeadersPacket(1, !kFin)); 532 AddWrite(ConstructDataPacket(2, kIncludeVersion, !kFin, 0, kUploadData)); 533 AddWrite(ConstructDataPacket(3, kIncludeVersion, kFin, chunk_size, 534 kUploadData)); 535 AddWrite(ConstructAckPacket(4, 3, 1)); 536 Initialize(); 537 538 UploadDataStream upload_data_stream(UploadDataStream::CHUNKED, 0); 539 upload_data_stream.AppendChunk(kUploadData, chunk_size, false); 540 541 request_.method = "POST"; 542 request_.url = GURL("http://www.google.com/"); 543 request_.upload_data_stream = &upload_data_stream; 544 ASSERT_EQ(OK, request_.upload_data_stream->Init(CompletionCallback())); 545 546 ASSERT_EQ(OK, stream_->InitializeStream(&request_, DEFAULT_PRIORITY, 547 net_log_, callback_.callback())); 548 ASSERT_EQ(ERR_IO_PENDING, stream_->SendRequest(headers_, &response_, 549 callback_.callback())); 550 551 upload_data_stream.AppendChunk(kUploadData, chunk_size, true); 552 553 // Ack both packets in the request. 554 ProcessPacket(ConstructAckPacket(1, 0, 0)); 555 556 // Send the response headers (but not the body). 557 SetResponse("200 OK", std::string()); 558 ProcessPacket(ConstructResponseHeadersPacket(2, !kFin)); 559 560 // Since the headers have already arrived, this should return immediately. 561 ASSERT_EQ(OK, stream_->ReadResponseHeaders(callback_.callback())); 562 ASSERT_TRUE(response_.headers.get()); 563 EXPECT_EQ(200, response_.headers->response_code()); 564 EXPECT_TRUE(response_.headers->HasHeaderValue("Content-Type", "text/plain")); 565 566 // Send the response body. 567 const char kResponseBody[] = "Hello world!"; 568 ProcessPacket(ConstructDataPacket(3, false, kFin, response_data_.length(), 569 kResponseBody)); 570 571 // Since the body has already arrived, this should return immediately. 572 ASSERT_EQ(static_cast<int>(strlen(kResponseBody)), 573 stream_->ReadResponseBody(read_buffer_.get(), read_buffer_->size(), 574 callback_.callback())); 575 576 EXPECT_TRUE(stream_->IsResponseBodyComplete()); 577 EXPECT_TRUE(AtEof()); 578 } 579 580 TEST_P(QuicHttpStreamTest, SendChunkedPostRequestWithFinalEmptyDataPacket) { 581 SetRequest("POST", "/", DEFAULT_PRIORITY); 582 size_t chunk_size = strlen(kUploadData); 583 AddWrite(ConstructRequestHeadersPacket(1, !kFin)); 584 AddWrite(ConstructDataPacket(2, kIncludeVersion, !kFin, 0, kUploadData)); 585 AddWrite(ConstructDataPacket(3, kIncludeVersion, kFin, chunk_size, "")); 586 AddWrite(ConstructAckPacket(4, 3, 1)); 587 Initialize(); 588 589 UploadDataStream upload_data_stream(UploadDataStream::CHUNKED, 0); 590 upload_data_stream.AppendChunk(kUploadData, chunk_size, false); 591 592 request_.method = "POST"; 593 request_.url = GURL("http://www.google.com/"); 594 request_.upload_data_stream = &upload_data_stream; 595 ASSERT_EQ(OK, request_.upload_data_stream->Init(CompletionCallback())); 596 597 ASSERT_EQ(OK, stream_->InitializeStream(&request_, DEFAULT_PRIORITY, 598 net_log_, callback_.callback())); 599 ASSERT_EQ(ERR_IO_PENDING, stream_->SendRequest(headers_, &response_, 600 callback_.callback())); 601 602 upload_data_stream.AppendChunk(NULL, 0, true); 603 604 ProcessPacket(ConstructAckPacket(1, 0, 0)); 605 606 // Send the response headers (but not the body). 607 SetResponse("200 OK", std::string()); 608 ProcessPacket(ConstructResponseHeadersPacket(2, !kFin)); 609 610 // Since the headers have already arrived, this should return immediately. 611 ASSERT_EQ(OK, stream_->ReadResponseHeaders(callback_.callback())); 612 ASSERT_TRUE(response_.headers.get()); 613 EXPECT_EQ(200, response_.headers->response_code()); 614 EXPECT_TRUE(response_.headers->HasHeaderValue("Content-Type", "text/plain")); 615 616 // Send the response body. 617 const char kResponseBody[] = "Hello world!"; 618 ProcessPacket(ConstructDataPacket(3, false, kFin, response_data_.length(), 619 kResponseBody)); 620 621 // Since the body has already arrived, this should return immediately. 622 ASSERT_EQ(static_cast<int>(strlen(kResponseBody)), 623 stream_->ReadResponseBody(read_buffer_.get(), read_buffer_->size(), 624 callback_.callback())); 625 626 EXPECT_TRUE(stream_->IsResponseBodyComplete()); 627 EXPECT_TRUE(AtEof()); 628 } 629 630 TEST_P(QuicHttpStreamTest, SendChunkedPostRequestWithOneEmptyDataPacket) { 631 SetRequest("POST", "/", DEFAULT_PRIORITY); 632 AddWrite(ConstructRequestHeadersPacket(1, !kFin)); 633 AddWrite(ConstructDataPacket(2, kIncludeVersion, kFin, 0, "")); 634 AddWrite(ConstructAckPacket(3, 3, 1)); 635 Initialize(); 636 637 UploadDataStream upload_data_stream(UploadDataStream::CHUNKED, 0); 638 639 request_.method = "POST"; 640 request_.url = GURL("http://www.google.com/"); 641 request_.upload_data_stream = &upload_data_stream; 642 ASSERT_EQ(OK, request_.upload_data_stream->Init(CompletionCallback())); 643 644 ASSERT_EQ(OK, stream_->InitializeStream(&request_, DEFAULT_PRIORITY, 645 net_log_, callback_.callback())); 646 ASSERT_EQ(ERR_IO_PENDING, stream_->SendRequest(headers_, &response_, 647 callback_.callback())); 648 649 upload_data_stream.AppendChunk(NULL, 0, true); 650 651 ProcessPacket(ConstructAckPacket(1, 0, 0)); 652 653 // Send the response headers (but not the body). 654 SetResponse("200 OK", std::string()); 655 ProcessPacket(ConstructResponseHeadersPacket(2, !kFin)); 656 657 // Since the headers have already arrived, this should return immediately. 658 ASSERT_EQ(OK, stream_->ReadResponseHeaders(callback_.callback())); 659 ASSERT_TRUE(response_.headers.get()); 660 EXPECT_EQ(200, response_.headers->response_code()); 661 EXPECT_TRUE(response_.headers->HasHeaderValue("Content-Type", "text/plain")); 662 663 // Send the response body. 664 const char kResponseBody[] = "Hello world!"; 665 ProcessPacket(ConstructDataPacket(3, false, kFin, response_data_.length(), 666 kResponseBody)); 667 668 // Since the body has already arrived, this should return immediately. 669 ASSERT_EQ(static_cast<int>(strlen(kResponseBody)), 670 stream_->ReadResponseBody(read_buffer_.get(), read_buffer_->size(), 671 callback_.callback())); 672 673 EXPECT_TRUE(stream_->IsResponseBodyComplete()); 674 EXPECT_TRUE(AtEof()); 675 } 676 677 TEST_P(QuicHttpStreamTest, DestroyedEarly) { 678 SetRequest("GET", "/", DEFAULT_PRIORITY); 679 AddWrite(ConstructRequestHeadersPacket(1, kFin)); 680 AddWrite(ConstructAckAndRstStreamPacket(2)); 681 use_closing_stream_ = true; 682 Initialize(); 683 684 request_.method = "GET"; 685 request_.url = GURL("http://www.google.com/"); 686 687 EXPECT_EQ(OK, stream_->InitializeStream(&request_, DEFAULT_PRIORITY, 688 net_log_, callback_.callback())); 689 EXPECT_EQ(OK, stream_->SendRequest(headers_, &response_, 690 callback_.callback())); 691 692 // Ack the request. 693 ProcessPacket(ConstructAckPacket(1, 0, 0)); 694 EXPECT_EQ(ERR_IO_PENDING, 695 stream_->ReadResponseHeaders(callback_.callback())); 696 697 // Send the response with a body. 698 SetResponse("404 OK", "hello world!"); 699 // In the course of processing this packet, the QuicHttpStream close itself. 700 ProcessPacket(ConstructResponseHeadersPacket(2, kFin)); 701 702 EXPECT_TRUE(AtEof()); 703 } 704 705 TEST_P(QuicHttpStreamTest, Priority) { 706 SetRequest("GET", "/", MEDIUM); 707 AddWrite(ConstructRequestHeadersPacket(1, kFin)); 708 AddWrite(ConstructAckAndRstStreamPacket(2)); 709 use_closing_stream_ = true; 710 Initialize(); 711 712 request_.method = "GET"; 713 request_.url = GURL("http://www.google.com/"); 714 715 EXPECT_EQ(OK, stream_->InitializeStream(&request_, MEDIUM, 716 net_log_, callback_.callback())); 717 718 // Check that priority is highest. 719 QuicReliableClientStream* reliable_stream = 720 QuicHttpStreamPeer::GetQuicReliableClientStream(stream_.get()); 721 DCHECK(reliable_stream); 722 DCHECK_EQ(QuicWriteBlockedList::kHighestPriority, 723 reliable_stream->EffectivePriority()); 724 725 EXPECT_EQ(OK, stream_->SendRequest(headers_, &response_, 726 callback_.callback())); 727 728 // Check that priority has now dropped back to MEDIUM. 729 DCHECK_EQ(MEDIUM, ConvertQuicPriorityToRequestPriority( 730 reliable_stream->EffectivePriority())); 731 732 // Ack the request. 733 ProcessPacket(ConstructAckPacket(1, 0, 0)); 734 EXPECT_EQ(ERR_IO_PENDING, 735 stream_->ReadResponseHeaders(callback_.callback())); 736 737 // Send the response with a body. 738 SetResponse("404 OK", "hello world!"); 739 // In the course of processing this packet, the QuicHttpStream close itself. 740 ProcessPacket(ConstructResponseHeadersPacket(2, kFin)); 741 742 EXPECT_TRUE(AtEof()); 743 } 744 745 // Regression test for http://crbug.com/294870 746 TEST_P(QuicHttpStreamTest, CheckPriorityWithNoDelegate) { 747 SetRequest("GET", "/", MEDIUM); 748 use_closing_stream_ = true; 749 750 AddWrite(ConstructRstStreamPacket(1)); 751 752 Initialize(); 753 754 request_.method = "GET"; 755 request_.url = GURL("http://www.google.com/"); 756 757 EXPECT_EQ(OK, stream_->InitializeStream(&request_, MEDIUM, 758 net_log_, callback_.callback())); 759 760 // Check that priority is highest. 761 QuicReliableClientStream* reliable_stream = 762 QuicHttpStreamPeer::GetQuicReliableClientStream(stream_.get()); 763 DCHECK(reliable_stream); 764 QuicReliableClientStream::Delegate* delegate = reliable_stream->GetDelegate(); 765 DCHECK(delegate); 766 DCHECK_EQ(QuicWriteBlockedList::kHighestPriority, 767 reliable_stream->EffectivePriority()); 768 769 // Set Delegate to NULL and make sure EffectivePriority returns highest 770 // priority. 771 reliable_stream->SetDelegate(NULL); 772 DCHECK_EQ(QuicWriteBlockedList::kHighestPriority, 773 reliable_stream->EffectivePriority()); 774 reliable_stream->SetDelegate(delegate); 775 } 776 777 } // namespace test 778 } // namespace net 779
