OLD | NEW |
1 // Copyright (c) 2012 The Chromium Authors. All rights reserved. | 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 | 2 // Use of this source code is governed by a BSD-style license that can be |
3 // found in the LICENSE file. | 3 // found in the LICENSE file. |
4 | 4 |
5 #include "net/quic/quic_http_stream.h" | 5 #include "net/quic/quic_http_stream.h" |
6 | 6 |
7 #include <stdint.h> | 7 #include <stdint.h> |
8 | 8 |
9 #include <vector> | 9 #include <vector> |
10 | 10 |
(...skipping 68 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
79 }; | 79 }; |
80 | 80 |
81 // Subclass of QuicHttpStream that closes itself when the first piece of data | 81 // Subclass of QuicHttpStream that closes itself when the first piece of data |
82 // is received. | 82 // is received. |
83 class AutoClosingStream : public QuicHttpStream { | 83 class AutoClosingStream : public QuicHttpStream { |
84 public: | 84 public: |
85 explicit AutoClosingStream( | 85 explicit AutoClosingStream( |
86 const base::WeakPtr<QuicChromiumClientSession>& session) | 86 const base::WeakPtr<QuicChromiumClientSession>& session) |
87 : QuicHttpStream(session) {} | 87 : QuicHttpStream(session) {} |
88 | 88 |
89 void OnHeadersAvailable(const SpdyHeaderBlock& headers) override { | 89 void OnHeadersAvailable(const SpdyHeaderBlock& headers, |
| 90 size_t frame_len) override { |
90 Close(false); | 91 Close(false); |
91 } | 92 } |
92 | 93 |
93 void OnDataAvailable() override { Close(false); } | 94 void OnDataAvailable() override { Close(false); } |
94 }; | 95 }; |
95 | 96 |
96 class TestPacketWriterFactory : public QuicConnection::PacketWriterFactory { | 97 class TestPacketWriterFactory : public QuicConnection::PacketWriterFactory { |
97 public: | 98 public: |
98 explicit TestPacketWriterFactory(DatagramClientSocket* socket) | 99 explicit TestPacketWriterFactory(DatagramClientSocket* socket) |
99 : socket_(socket) {} | 100 : socket_(socket) {} |
(...skipping 150 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
250 bool fin, | 251 bool fin, |
251 QuicStreamOffset offset, | 252 QuicStreamOffset offset, |
252 base::StringPiece data) { | 253 base::StringPiece data) { |
253 return maker_.MakeDataPacket(packet_number, stream_id_, | 254 return maker_.MakeDataPacket(packet_number, stream_id_, |
254 should_include_version, fin, offset, data); | 255 should_include_version, fin, offset, data); |
255 } | 256 } |
256 | 257 |
257 scoped_ptr<QuicEncryptedPacket> ConstructRequestHeadersPacket( | 258 scoped_ptr<QuicEncryptedPacket> ConstructRequestHeadersPacket( |
258 QuicPacketNumber packet_number, | 259 QuicPacketNumber packet_number, |
259 bool fin, | 260 bool fin, |
260 RequestPriority request_priority) { | 261 RequestPriority request_priority, |
| 262 size_t* spdy_headers_frame_length) { |
261 QuicPriority priority = | 263 QuicPriority priority = |
262 ConvertRequestPriorityToQuicPriority(request_priority); | 264 ConvertRequestPriorityToQuicPriority(request_priority); |
263 return maker_.MakeRequestHeadersPacket(packet_number, stream_id_, | 265 return maker_.MakeRequestHeadersPacket( |
264 kIncludeVersion, fin, priority, | 266 packet_number, stream_id_, kIncludeVersion, fin, priority, |
265 request_headers_); | 267 request_headers_, spdy_headers_frame_length); |
266 } | 268 } |
267 | 269 |
268 scoped_ptr<QuicEncryptedPacket> ConstructResponseHeadersPacket( | 270 scoped_ptr<QuicEncryptedPacket> ConstructResponseHeadersPacket( |
269 QuicPacketNumber packet_number, | 271 QuicPacketNumber packet_number, |
270 bool fin) { | 272 bool fin, |
| 273 size_t* spdy_headers_frame_length) { |
271 return maker_.MakeResponseHeadersPacket( | 274 return maker_.MakeResponseHeadersPacket( |
272 packet_number, stream_id_, !kIncludeVersion, fin, response_headers_); | 275 packet_number, stream_id_, !kIncludeVersion, fin, response_headers_, |
| 276 spdy_headers_frame_length); |
273 } | 277 } |
274 | 278 |
275 scoped_ptr<QuicEncryptedPacket> ConstructRstStreamPacket( | 279 scoped_ptr<QuicEncryptedPacket> ConstructRstStreamPacket( |
276 QuicPacketNumber packet_number) { | 280 QuicPacketNumber packet_number) { |
277 return maker_.MakeRstPacket( | 281 return maker_.MakeRstPacket( |
278 packet_number, true, stream_id_, | 282 packet_number, true, stream_id_, |
279 AdjustErrorForVersion(QUIC_RST_ACKNOWLEDGEMENT, GetParam())); | 283 AdjustErrorForVersion(QUIC_RST_ACKNOWLEDGEMENT, GetParam())); |
280 } | 284 } |
281 | 285 |
282 scoped_ptr<QuicEncryptedPacket> ConstructRstStreamCancelledPacket( | 286 scoped_ptr<QuicEncryptedPacket> ConstructRstStreamCancelledPacket( |
(...skipping 60 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
343 EXPECT_EQ(nullptr, stream_->RenewStreamForAuth()); | 347 EXPECT_EQ(nullptr, stream_->RenewStreamForAuth()); |
344 } | 348 } |
345 | 349 |
346 TEST_P(QuicHttpStreamTest, CanReuseConnection) { | 350 TEST_P(QuicHttpStreamTest, CanReuseConnection) { |
347 Initialize(); | 351 Initialize(); |
348 EXPECT_FALSE(stream_->CanReuseConnection()); | 352 EXPECT_FALSE(stream_->CanReuseConnection()); |
349 } | 353 } |
350 | 354 |
351 TEST_P(QuicHttpStreamTest, GetRequest) { | 355 TEST_P(QuicHttpStreamTest, GetRequest) { |
352 SetRequest("GET", "/", DEFAULT_PRIORITY); | 356 SetRequest("GET", "/", DEFAULT_PRIORITY); |
353 AddWrite(ConstructRequestHeadersPacket(1, kFin, DEFAULT_PRIORITY)); | 357 size_t spdy_request_header_frame_length; |
| 358 AddWrite(ConstructRequestHeadersPacket(1, kFin, DEFAULT_PRIORITY, |
| 359 &spdy_request_header_frame_length)); |
354 Initialize(); | 360 Initialize(); |
355 | 361 |
356 request_.method = "GET"; | 362 request_.method = "GET"; |
357 request_.url = GURL("http://www.google.com/"); | 363 request_.url = GURL("http://www.google.com/"); |
358 | 364 |
359 EXPECT_EQ(OK, stream_->InitializeStream(&request_, DEFAULT_PRIORITY, | 365 EXPECT_EQ(OK, stream_->InitializeStream(&request_, DEFAULT_PRIORITY, |
360 net_log_, callback_.callback())); | 366 net_log_, callback_.callback())); |
361 EXPECT_EQ(OK, stream_->SendRequest(headers_, &response_, | 367 EXPECT_EQ(OK, stream_->SendRequest(headers_, &response_, |
362 callback_.callback())); | 368 callback_.callback())); |
363 | 369 |
364 // Ack the request. | 370 // Ack the request. |
365 ProcessPacket(ConstructAckPacket(1, 0, 0)); | 371 ProcessPacket(ConstructAckPacket(1, 0, 0)); |
366 | 372 |
367 EXPECT_EQ(ERR_IO_PENDING, | 373 EXPECT_EQ(ERR_IO_PENDING, |
368 stream_->ReadResponseHeaders(callback_.callback())); | 374 stream_->ReadResponseHeaders(callback_.callback())); |
369 | 375 |
370 SetResponse("404 Not Found", std::string()); | 376 SetResponse("404 Not Found", std::string()); |
371 ProcessPacket(ConstructResponseHeadersPacket(2, kFin)); | 377 size_t spdy_response_header_frame_length; |
| 378 ProcessPacket(ConstructResponseHeadersPacket( |
| 379 2, kFin, &spdy_response_header_frame_length)); |
372 | 380 |
373 // Now that the headers have been processed, the callback will return. | 381 // Now that the headers have been processed, the callback will return. |
374 EXPECT_EQ(OK, callback_.WaitForResult()); | 382 EXPECT_EQ(OK, callback_.WaitForResult()); |
375 ASSERT_TRUE(response_.headers.get()); | 383 ASSERT_TRUE(response_.headers.get()); |
376 EXPECT_EQ(404, response_.headers->response_code()); | 384 EXPECT_EQ(404, response_.headers->response_code()); |
377 EXPECT_TRUE(response_.headers->HasHeaderValue("Content-Type", "text/plain")); | 385 EXPECT_TRUE(response_.headers->HasHeaderValue("Content-Type", "text/plain")); |
378 EXPECT_FALSE(response_.response_time.is_null()); | 386 EXPECT_FALSE(response_.response_time.is_null()); |
379 EXPECT_FALSE(response_.request_time.is_null()); | 387 EXPECT_FALSE(response_.request_time.is_null()); |
380 | 388 |
381 // There is no body, so this should return immediately. | 389 // There is no body, so this should return immediately. |
382 EXPECT_EQ(0, stream_->ReadResponseBody(read_buffer_.get(), | 390 EXPECT_EQ(0, stream_->ReadResponseBody(read_buffer_.get(), |
383 read_buffer_->size(), | 391 read_buffer_->size(), |
384 callback_.callback())); | 392 callback_.callback())); |
385 EXPECT_TRUE(stream_->IsResponseBodyComplete()); | 393 EXPECT_TRUE(stream_->IsResponseBodyComplete()); |
386 EXPECT_TRUE(AtEof()); | 394 EXPECT_TRUE(AtEof()); |
387 | 395 |
388 // QuicHttpStream::GetTotalSent/ReceivedBytes currently only includes the | 396 // QuicHttpStream::GetTotalSent/ReceivedBytes currently only includes the |
389 // payload. | 397 // headers and payload. |
390 EXPECT_EQ(0, stream_->GetTotalSentBytes()); | 398 EXPECT_EQ(static_cast<int64_t>(spdy_request_header_frame_length), |
391 EXPECT_EQ(0, stream_->GetTotalReceivedBytes()); | 399 stream_->GetTotalSentBytes()); |
| 400 EXPECT_EQ(static_cast<int64_t>(spdy_response_header_frame_length), |
| 401 stream_->GetTotalReceivedBytes()); |
392 } | 402 } |
393 | 403 |
394 // Regression test for http://crbug.com/288128 | 404 // Regression test for http://crbug.com/288128 |
395 TEST_P(QuicHttpStreamTest, GetRequestLargeResponse) { | 405 TEST_P(QuicHttpStreamTest, GetRequestLargeResponse) { |
396 SetRequest("GET", "/", DEFAULT_PRIORITY); | 406 SetRequest("GET", "/", DEFAULT_PRIORITY); |
397 AddWrite(ConstructRequestHeadersPacket(1, kFin, DEFAULT_PRIORITY)); | 407 size_t spdy_request_headers_frame_length; |
| 408 AddWrite(ConstructRequestHeadersPacket(1, kFin, DEFAULT_PRIORITY, |
| 409 &spdy_request_headers_frame_length)); |
398 Initialize(); | 410 Initialize(); |
399 | 411 |
400 request_.method = "GET"; | 412 request_.method = "GET"; |
401 request_.url = GURL("http://www.google.com/"); | 413 request_.url = GURL("http://www.google.com/"); |
402 | 414 |
403 EXPECT_EQ(OK, stream_->InitializeStream(&request_, DEFAULT_PRIORITY, | 415 EXPECT_EQ(OK, stream_->InitializeStream(&request_, DEFAULT_PRIORITY, |
404 net_log_, callback_.callback())); | 416 net_log_, callback_.callback())); |
405 EXPECT_EQ(OK, stream_->SendRequest(headers_, &response_, | 417 EXPECT_EQ(OK, stream_->SendRequest(headers_, &response_, |
406 callback_.callback())); | 418 callback_.callback())); |
407 | 419 |
408 // Ack the request. | 420 // Ack the request. |
409 ProcessPacket(ConstructAckPacket(1, 0, 0)); | 421 ProcessPacket(ConstructAckPacket(1, 0, 0)); |
410 | 422 |
411 EXPECT_EQ(ERR_IO_PENDING, | 423 EXPECT_EQ(ERR_IO_PENDING, |
412 stream_->ReadResponseHeaders(callback_.callback())); | 424 stream_->ReadResponseHeaders(callback_.callback())); |
413 | 425 |
414 SpdyHeaderBlock headers; | 426 SpdyHeaderBlock headers; |
415 headers[":status"] = "200 OK"; | 427 headers[":status"] = "200 OK"; |
416 headers[":version"] = "HTTP/1.1"; | 428 headers[":version"] = "HTTP/1.1"; |
417 headers["content-type"] = "text/plain"; | 429 headers["content-type"] = "text/plain"; |
418 headers["big6"] = std::string(1000, 'x'); // Lots of x's. | 430 headers["big6"] = std::string(1000, 'x'); // Lots of x's. |
419 | 431 |
420 response_headers_ = headers; | 432 response_headers_ = headers; |
421 ProcessPacket(ConstructResponseHeadersPacket(2, kFin)); | 433 size_t spdy_response_headers_frame_length; |
| 434 ProcessPacket(ConstructResponseHeadersPacket( |
| 435 2, kFin, &spdy_response_headers_frame_length)); |
422 | 436 |
423 // Now that the headers have been processed, the callback will return. | 437 // Now that the headers have been processed, the callback will return. |
424 EXPECT_EQ(OK, callback_.WaitForResult()); | 438 EXPECT_EQ(OK, callback_.WaitForResult()); |
425 ASSERT_TRUE(response_.headers.get()); | 439 ASSERT_TRUE(response_.headers.get()); |
426 EXPECT_EQ(200, response_.headers->response_code()); | 440 EXPECT_EQ(200, response_.headers->response_code()); |
427 EXPECT_TRUE(response_.headers->HasHeaderValue("Content-Type", "text/plain")); | 441 EXPECT_TRUE(response_.headers->HasHeaderValue("Content-Type", "text/plain")); |
428 | 442 |
429 // There is no body, so this should return immediately. | 443 // There is no body, so this should return immediately. |
430 EXPECT_EQ(0, stream_->ReadResponseBody(read_buffer_.get(), | 444 EXPECT_EQ(0, stream_->ReadResponseBody(read_buffer_.get(), |
431 read_buffer_->size(), | 445 read_buffer_->size(), |
432 callback_.callback())); | 446 callback_.callback())); |
433 EXPECT_TRUE(stream_->IsResponseBodyComplete()); | 447 EXPECT_TRUE(stream_->IsResponseBodyComplete()); |
434 EXPECT_TRUE(AtEof()); | 448 EXPECT_TRUE(AtEof()); |
435 | 449 |
436 // QuicHttpStream::GetTotalSent/ReceivedBytes currently only includes the | 450 // QuicHttpStream::GetTotalSent/ReceivedBytes currently only includes the |
437 // payload. | 451 // headers and payload. |
438 EXPECT_EQ(0, stream_->GetTotalSentBytes()); | 452 EXPECT_EQ(static_cast<int64_t>(spdy_request_headers_frame_length), |
439 EXPECT_EQ(0, stream_->GetTotalReceivedBytes()); | 453 stream_->GetTotalSentBytes()); |
| 454 EXPECT_EQ(static_cast<int64_t>(spdy_response_headers_frame_length), |
| 455 stream_->GetTotalReceivedBytes()); |
440 } | 456 } |
441 | 457 |
442 // Regression test for http://crbug.com/409101 | 458 // Regression test for http://crbug.com/409101 |
443 TEST_P(QuicHttpStreamTest, SessionClosedBeforeSendRequest) { | 459 TEST_P(QuicHttpStreamTest, SessionClosedBeforeSendRequest) { |
444 SetRequest("GET", "/", DEFAULT_PRIORITY); | 460 SetRequest("GET", "/", DEFAULT_PRIORITY); |
445 Initialize(); | 461 Initialize(); |
446 | 462 |
447 request_.method = "GET"; | 463 request_.method = "GET"; |
448 request_.url = GURL("http://www.google.com/"); | 464 request_.url = GURL("http://www.google.com/"); |
449 | 465 |
450 EXPECT_EQ(OK, stream_->InitializeStream(&request_, DEFAULT_PRIORITY, | 466 EXPECT_EQ(OK, stream_->InitializeStream(&request_, DEFAULT_PRIORITY, |
451 net_log_, callback_.callback())); | 467 net_log_, callback_.callback())); |
452 | 468 |
453 session_->connection()->CloseConnection(QUIC_NO_ERROR, true); | 469 session_->connection()->CloseConnection(QUIC_NO_ERROR, true); |
454 | 470 |
455 EXPECT_EQ(ERR_CONNECTION_CLOSED, | 471 EXPECT_EQ(ERR_CONNECTION_CLOSED, |
456 stream_->SendRequest(headers_, &response_, | 472 stream_->SendRequest(headers_, &response_, |
457 callback_.callback())); | 473 callback_.callback())); |
458 | 474 |
459 EXPECT_EQ(0, stream_->GetTotalSentBytes()); | 475 EXPECT_EQ(0, stream_->GetTotalSentBytes()); |
460 EXPECT_EQ(0, stream_->GetTotalReceivedBytes()); | 476 EXPECT_EQ(0, stream_->GetTotalReceivedBytes()); |
461 } | 477 } |
462 | 478 |
463 // Regression test for http://crbug.com/409871 | 479 // Regression test for http://crbug.com/409871 |
464 TEST_P(QuicHttpStreamTest, SessionClosedBeforeReadResponseHeaders) { | 480 TEST_P(QuicHttpStreamTest, SessionClosedBeforeReadResponseHeaders) { |
465 SetRequest("GET", "/", DEFAULT_PRIORITY); | 481 SetRequest("GET", "/", DEFAULT_PRIORITY); |
466 AddWrite(ConstructRequestHeadersPacket(1, kFin, DEFAULT_PRIORITY)); | 482 size_t spdy_request_headers_frame_length; |
| 483 AddWrite(ConstructRequestHeadersPacket(1, kFin, DEFAULT_PRIORITY, |
| 484 &spdy_request_headers_frame_length)); |
467 Initialize(); | 485 Initialize(); |
468 | 486 |
469 request_.method = "GET"; | 487 request_.method = "GET"; |
470 request_.url = GURL("http://www.google.com/"); | 488 request_.url = GURL("http://www.google.com/"); |
471 | 489 |
472 EXPECT_EQ(OK, stream_->InitializeStream(&request_, DEFAULT_PRIORITY, | 490 EXPECT_EQ(OK, stream_->InitializeStream(&request_, DEFAULT_PRIORITY, |
473 net_log_, callback_.callback())); | 491 net_log_, callback_.callback())); |
474 | 492 |
475 EXPECT_EQ(OK, stream_->SendRequest(headers_, &response_, | 493 EXPECT_EQ(OK, stream_->SendRequest(headers_, &response_, |
476 callback_.callback())); | 494 callback_.callback())); |
477 | 495 |
478 session_->connection()->CloseConnection(QUIC_NO_ERROR, true); | 496 session_->connection()->CloseConnection(QUIC_NO_ERROR, true); |
479 | 497 |
480 EXPECT_NE(OK, stream_->ReadResponseHeaders(callback_.callback())); | 498 EXPECT_NE(OK, stream_->ReadResponseHeaders(callback_.callback())); |
481 | 499 |
482 // QuicHttpStream::GetTotalSent/ReceivedBytes currently only includes the | 500 // QuicHttpStream::GetTotalSent/ReceivedBytes currently only includes the |
483 // payload. | 501 // headers and payload. |
484 EXPECT_EQ(0, stream_->GetTotalSentBytes()); | 502 EXPECT_EQ(static_cast<int64_t>(spdy_request_headers_frame_length), |
| 503 stream_->GetTotalSentBytes()); |
485 EXPECT_EQ(0, stream_->GetTotalReceivedBytes()); | 504 EXPECT_EQ(0, stream_->GetTotalReceivedBytes()); |
486 } | 505 } |
487 | 506 |
488 TEST_P(QuicHttpStreamTest, SendPostRequest) { | 507 TEST_P(QuicHttpStreamTest, SendPostRequest) { |
489 SetRequest("POST", "/", DEFAULT_PRIORITY); | 508 SetRequest("POST", "/", DEFAULT_PRIORITY); |
490 AddWrite(ConstructRequestHeadersPacket(1, !kFin, DEFAULT_PRIORITY)); | 509 size_t spdy_request_headers_frame_length; |
| 510 AddWrite(ConstructRequestHeadersPacket(1, !kFin, DEFAULT_PRIORITY, |
| 511 &spdy_request_headers_frame_length)); |
491 AddWrite(ConstructDataPacket(2, kIncludeVersion, kFin, 0, kUploadData)); | 512 AddWrite(ConstructDataPacket(2, kIncludeVersion, kFin, 0, kUploadData)); |
492 AddWrite(ConstructAckPacket(3, 3, 1)); | 513 AddWrite(ConstructAckPacket(3, 3, 1)); |
493 | 514 |
494 Initialize(); | 515 Initialize(); |
495 | 516 |
496 ScopedVector<UploadElementReader> element_readers; | 517 ScopedVector<UploadElementReader> element_readers; |
497 element_readers.push_back( | 518 element_readers.push_back( |
498 new UploadBytesElementReader(kUploadData, strlen(kUploadData))); | 519 new UploadBytesElementReader(kUploadData, strlen(kUploadData))); |
499 ElementsUploadDataStream upload_data_stream(element_readers.Pass(), 0); | 520 ElementsUploadDataStream upload_data_stream(element_readers.Pass(), 0); |
500 request_.method = "POST"; | 521 request_.method = "POST"; |
501 request_.url = GURL("http://www.google.com/"); | 522 request_.url = GURL("http://www.google.com/"); |
502 request_.upload_data_stream = &upload_data_stream; | 523 request_.upload_data_stream = &upload_data_stream; |
503 ASSERT_EQ(OK, request_.upload_data_stream->Init(CompletionCallback())); | 524 ASSERT_EQ(OK, request_.upload_data_stream->Init(CompletionCallback())); |
504 | 525 |
505 EXPECT_EQ(OK, stream_->InitializeStream(&request_, DEFAULT_PRIORITY, | 526 EXPECT_EQ(OK, stream_->InitializeStream(&request_, DEFAULT_PRIORITY, |
506 net_log_, callback_.callback())); | 527 net_log_, callback_.callback())); |
507 EXPECT_EQ(OK, stream_->SendRequest(headers_, &response_, | 528 EXPECT_EQ(OK, stream_->SendRequest(headers_, &response_, |
508 callback_.callback())); | 529 callback_.callback())); |
509 | 530 |
510 // Ack both packets in the request. | 531 // Ack both packets in the request. |
511 ProcessPacket(ConstructAckPacket(1, 0, 0)); | 532 ProcessPacket(ConstructAckPacket(1, 0, 0)); |
512 | 533 |
513 // Send the response headers (but not the body). | 534 // Send the response headers (but not the body). |
514 SetResponse("200 OK", std::string()); | 535 SetResponse("200 OK", std::string()); |
515 ProcessPacket(ConstructResponseHeadersPacket(2, !kFin)); | 536 size_t spdy_response_headers_frame_length; |
| 537 ProcessPacket(ConstructResponseHeadersPacket( |
| 538 2, !kFin, &spdy_response_headers_frame_length)); |
516 | 539 |
517 // The headers have arrived, but they are delivered asynchronously. | 540 // The headers have arrived, but they are delivered asynchronously. |
518 EXPECT_EQ(ERR_IO_PENDING, stream_->ReadResponseHeaders(callback_.callback())); | 541 EXPECT_EQ(ERR_IO_PENDING, stream_->ReadResponseHeaders(callback_.callback())); |
519 EXPECT_EQ(OK, callback_.WaitForResult()); | 542 EXPECT_EQ(OK, callback_.WaitForResult()); |
520 ASSERT_TRUE(response_.headers.get()); | 543 ASSERT_TRUE(response_.headers.get()); |
521 EXPECT_EQ(200, response_.headers->response_code()); | 544 EXPECT_EQ(200, response_.headers->response_code()); |
522 EXPECT_TRUE(response_.headers->HasHeaderValue("Content-Type", "text/plain")); | 545 EXPECT_TRUE(response_.headers->HasHeaderValue("Content-Type", "text/plain")); |
523 | 546 |
524 // Send the response body. | 547 // Send the response body. |
525 const char kResponseBody[] = "Hello world!"; | 548 const char kResponseBody[] = "Hello world!"; |
526 ProcessPacket(ConstructDataPacket(3, false, kFin, 0, kResponseBody)); | 549 ProcessPacket(ConstructDataPacket(3, false, kFin, 0, kResponseBody)); |
527 // Since the body has already arrived, this should return immediately. | 550 // Since the body has already arrived, this should return immediately. |
528 EXPECT_EQ(static_cast<int>(strlen(kResponseBody)), | 551 EXPECT_EQ(static_cast<int>(strlen(kResponseBody)), |
529 stream_->ReadResponseBody(read_buffer_.get(), read_buffer_->size(), | 552 stream_->ReadResponseBody(read_buffer_.get(), read_buffer_->size(), |
530 callback_.callback())); | 553 callback_.callback())); |
531 | 554 |
532 EXPECT_TRUE(stream_->IsResponseBodyComplete()); | 555 EXPECT_TRUE(stream_->IsResponseBodyComplete()); |
533 EXPECT_TRUE(AtEof()); | 556 EXPECT_TRUE(AtEof()); |
534 | 557 |
535 // QuicHttpStream::GetTotalSent/ReceivedBytes currently only includes the | 558 // QuicHttpStream::GetTotalSent/ReceivedBytes currently only includes the |
536 // payload. | 559 // headers and payload. |
537 EXPECT_EQ(static_cast<int64_t>(strlen(kUploadData)), | 560 EXPECT_EQ(static_cast<int64_t>(spdy_request_headers_frame_length + |
| 561 strlen(kUploadData)), |
538 stream_->GetTotalSentBytes()); | 562 stream_->GetTotalSentBytes()); |
539 EXPECT_EQ(static_cast<int64_t>(strlen(kResponseBody)), | 563 EXPECT_EQ(static_cast<int64_t>(spdy_response_headers_frame_length + |
| 564 strlen(kResponseBody)), |
540 stream_->GetTotalReceivedBytes()); | 565 stream_->GetTotalReceivedBytes()); |
541 } | 566 } |
542 | 567 |
543 TEST_P(QuicHttpStreamTest, SendChunkedPostRequest) { | 568 TEST_P(QuicHttpStreamTest, SendChunkedPostRequest) { |
544 SetRequest("POST", "/", DEFAULT_PRIORITY); | 569 SetRequest("POST", "/", DEFAULT_PRIORITY); |
545 size_t chunk_size = strlen(kUploadData); | 570 size_t chunk_size = strlen(kUploadData); |
546 AddWrite(ConstructRequestHeadersPacket(1, !kFin, DEFAULT_PRIORITY)); | 571 size_t spdy_request_headers_frame_length; |
| 572 AddWrite(ConstructRequestHeadersPacket(1, !kFin, DEFAULT_PRIORITY, |
| 573 &spdy_request_headers_frame_length)); |
547 AddWrite(ConstructDataPacket(2, kIncludeVersion, !kFin, 0, kUploadData)); | 574 AddWrite(ConstructDataPacket(2, kIncludeVersion, !kFin, 0, kUploadData)); |
548 AddWrite(ConstructDataPacket(3, kIncludeVersion, kFin, chunk_size, | 575 AddWrite(ConstructDataPacket(3, kIncludeVersion, kFin, chunk_size, |
549 kUploadData)); | 576 kUploadData)); |
550 AddWrite(ConstructAckPacket(4, 3, 1)); | 577 AddWrite(ConstructAckPacket(4, 3, 1)); |
551 Initialize(); | 578 Initialize(); |
552 | 579 |
553 ChunkedUploadDataStream upload_data_stream(0); | 580 ChunkedUploadDataStream upload_data_stream(0); |
554 upload_data_stream.AppendData(kUploadData, chunk_size, false); | 581 upload_data_stream.AppendData(kUploadData, chunk_size, false); |
555 | 582 |
556 request_.method = "POST"; | 583 request_.method = "POST"; |
557 request_.url = GURL("http://www.google.com/"); | 584 request_.url = GURL("http://www.google.com/"); |
558 request_.upload_data_stream = &upload_data_stream; | 585 request_.upload_data_stream = &upload_data_stream; |
559 ASSERT_EQ(OK, request_.upload_data_stream->Init( | 586 ASSERT_EQ(OK, request_.upload_data_stream->Init( |
560 TestCompletionCallback().callback())); | 587 TestCompletionCallback().callback())); |
561 | 588 |
562 ASSERT_EQ(OK, stream_->InitializeStream(&request_, DEFAULT_PRIORITY, | 589 ASSERT_EQ(OK, stream_->InitializeStream(&request_, DEFAULT_PRIORITY, |
563 net_log_, callback_.callback())); | 590 net_log_, callback_.callback())); |
564 ASSERT_EQ(ERR_IO_PENDING, stream_->SendRequest(headers_, &response_, | 591 ASSERT_EQ(ERR_IO_PENDING, stream_->SendRequest(headers_, &response_, |
565 callback_.callback())); | 592 callback_.callback())); |
566 | 593 |
567 upload_data_stream.AppendData(kUploadData, chunk_size, true); | 594 upload_data_stream.AppendData(kUploadData, chunk_size, true); |
568 EXPECT_EQ(OK, callback_.WaitForResult()); | 595 EXPECT_EQ(OK, callback_.WaitForResult()); |
569 | 596 |
570 // Ack both packets in the request. | 597 // Ack both packets in the request. |
571 ProcessPacket(ConstructAckPacket(1, 0, 0)); | 598 ProcessPacket(ConstructAckPacket(1, 0, 0)); |
572 | 599 |
573 // Send the response headers (but not the body). | 600 // Send the response headers (but not the body). |
574 SetResponse("200 OK", std::string()); | 601 SetResponse("200 OK", std::string()); |
575 ProcessPacket(ConstructResponseHeadersPacket(2, !kFin)); | 602 size_t spdy_response_headers_frame_length; |
| 603 ProcessPacket(ConstructResponseHeadersPacket( |
| 604 2, !kFin, &spdy_response_headers_frame_length)); |
576 | 605 |
577 // The headers have arrived, but they are delivered asynchronously | 606 // The headers have arrived, but they are delivered asynchronously |
578 EXPECT_EQ(ERR_IO_PENDING, stream_->ReadResponseHeaders(callback_.callback())); | 607 EXPECT_EQ(ERR_IO_PENDING, stream_->ReadResponseHeaders(callback_.callback())); |
579 EXPECT_EQ(OK, callback_.WaitForResult()); | 608 EXPECT_EQ(OK, callback_.WaitForResult()); |
580 ASSERT_TRUE(response_.headers.get()); | 609 ASSERT_TRUE(response_.headers.get()); |
581 EXPECT_EQ(200, response_.headers->response_code()); | 610 EXPECT_EQ(200, response_.headers->response_code()); |
582 EXPECT_TRUE(response_.headers->HasHeaderValue("Content-Type", "text/plain")); | 611 EXPECT_TRUE(response_.headers->HasHeaderValue("Content-Type", "text/plain")); |
583 | 612 |
584 // Send the response body. | 613 // Send the response body. |
585 const char kResponseBody[] = "Hello world!"; | 614 const char kResponseBody[] = "Hello world!"; |
586 ProcessPacket(ConstructDataPacket(3, false, kFin, response_data_.length(), | 615 ProcessPacket(ConstructDataPacket(3, false, kFin, response_data_.length(), |
587 kResponseBody)); | 616 kResponseBody)); |
588 | 617 |
589 // Since the body has already arrived, this should return immediately. | 618 // Since the body has already arrived, this should return immediately. |
590 ASSERT_EQ(static_cast<int>(strlen(kResponseBody)), | 619 ASSERT_EQ(static_cast<int>(strlen(kResponseBody)), |
591 stream_->ReadResponseBody(read_buffer_.get(), read_buffer_->size(), | 620 stream_->ReadResponseBody(read_buffer_.get(), read_buffer_->size(), |
592 callback_.callback())); | 621 callback_.callback())); |
593 | 622 |
594 EXPECT_TRUE(stream_->IsResponseBodyComplete()); | 623 EXPECT_TRUE(stream_->IsResponseBodyComplete()); |
595 EXPECT_TRUE(AtEof()); | 624 EXPECT_TRUE(AtEof()); |
596 | 625 |
597 // QuicHttpStream::GetTotalSent/ReceivedBytes currently only includes the | 626 // QuicHttpStream::GetTotalSent/ReceivedBytes currently only includes the |
598 // payload. | 627 // headers and payload. |
599 EXPECT_EQ(static_cast<int64_t>(strlen(kUploadData) * 2), | 628 EXPECT_EQ(static_cast<int64_t>(spdy_request_headers_frame_length + |
| 629 strlen(kUploadData) * 2), |
600 stream_->GetTotalSentBytes()); | 630 stream_->GetTotalSentBytes()); |
601 EXPECT_EQ(static_cast<int64_t>(strlen(kResponseBody)), | 631 EXPECT_EQ(static_cast<int64_t>(spdy_response_headers_frame_length + |
| 632 strlen(kResponseBody)), |
602 stream_->GetTotalReceivedBytes()); | 633 stream_->GetTotalReceivedBytes()); |
603 } | 634 } |
604 | 635 |
605 TEST_P(QuicHttpStreamTest, SendChunkedPostRequestWithFinalEmptyDataPacket) { | 636 TEST_P(QuicHttpStreamTest, SendChunkedPostRequestWithFinalEmptyDataPacket) { |
606 SetRequest("POST", "/", DEFAULT_PRIORITY); | 637 SetRequest("POST", "/", DEFAULT_PRIORITY); |
607 size_t chunk_size = strlen(kUploadData); | 638 size_t chunk_size = strlen(kUploadData); |
608 AddWrite(ConstructRequestHeadersPacket(1, !kFin, DEFAULT_PRIORITY)); | 639 size_t spdy_request_headers_frame_length; |
| 640 AddWrite(ConstructRequestHeadersPacket(1, !kFin, DEFAULT_PRIORITY, |
| 641 &spdy_request_headers_frame_length)); |
609 AddWrite(ConstructDataPacket(2, kIncludeVersion, !kFin, 0, kUploadData)); | 642 AddWrite(ConstructDataPacket(2, kIncludeVersion, !kFin, 0, kUploadData)); |
610 AddWrite(ConstructDataPacket(3, kIncludeVersion, kFin, chunk_size, "")); | 643 AddWrite(ConstructDataPacket(3, kIncludeVersion, kFin, chunk_size, "")); |
611 AddWrite(ConstructAckPacket(4, 3, 1)); | 644 AddWrite(ConstructAckPacket(4, 3, 1)); |
612 Initialize(); | 645 Initialize(); |
613 | 646 |
614 ChunkedUploadDataStream upload_data_stream(0); | 647 ChunkedUploadDataStream upload_data_stream(0); |
615 upload_data_stream.AppendData(kUploadData, chunk_size, false); | 648 upload_data_stream.AppendData(kUploadData, chunk_size, false); |
616 | 649 |
617 request_.method = "POST"; | 650 request_.method = "POST"; |
618 request_.url = GURL("http://www.google.com/"); | 651 request_.url = GURL("http://www.google.com/"); |
619 request_.upload_data_stream = &upload_data_stream; | 652 request_.upload_data_stream = &upload_data_stream; |
620 ASSERT_EQ(OK, request_.upload_data_stream->Init( | 653 ASSERT_EQ(OK, request_.upload_data_stream->Init( |
621 TestCompletionCallback().callback())); | 654 TestCompletionCallback().callback())); |
622 | 655 |
623 ASSERT_EQ(OK, stream_->InitializeStream(&request_, DEFAULT_PRIORITY, | 656 ASSERT_EQ(OK, stream_->InitializeStream(&request_, DEFAULT_PRIORITY, |
624 net_log_, callback_.callback())); | 657 net_log_, callback_.callback())); |
625 ASSERT_EQ(ERR_IO_PENDING, stream_->SendRequest(headers_, &response_, | 658 ASSERT_EQ(ERR_IO_PENDING, stream_->SendRequest(headers_, &response_, |
626 callback_.callback())); | 659 callback_.callback())); |
627 | 660 |
628 upload_data_stream.AppendData(nullptr, 0, true); | 661 upload_data_stream.AppendData(nullptr, 0, true); |
629 EXPECT_EQ(OK, callback_.WaitForResult()); | 662 EXPECT_EQ(OK, callback_.WaitForResult()); |
630 | 663 |
631 ProcessPacket(ConstructAckPacket(1, 0, 0)); | 664 ProcessPacket(ConstructAckPacket(1, 0, 0)); |
632 | 665 |
633 // Send the response headers (but not the body). | 666 // Send the response headers (but not the body). |
634 SetResponse("200 OK", std::string()); | 667 SetResponse("200 OK", std::string()); |
635 ProcessPacket(ConstructResponseHeadersPacket(2, !kFin)); | 668 size_t spdy_response_headers_frame_length; |
| 669 ProcessPacket(ConstructResponseHeadersPacket( |
| 670 2, !kFin, &spdy_response_headers_frame_length)); |
636 | 671 |
637 // The headers have arrived, but they are delivered asynchronously | 672 // The headers have arrived, but they are delivered asynchronously |
638 EXPECT_EQ(ERR_IO_PENDING, stream_->ReadResponseHeaders(callback_.callback())); | 673 EXPECT_EQ(ERR_IO_PENDING, stream_->ReadResponseHeaders(callback_.callback())); |
639 EXPECT_EQ(OK, callback_.WaitForResult()); | 674 EXPECT_EQ(OK, callback_.WaitForResult()); |
640 ASSERT_TRUE(response_.headers.get()); | 675 ASSERT_TRUE(response_.headers.get()); |
641 EXPECT_EQ(200, response_.headers->response_code()); | 676 EXPECT_EQ(200, response_.headers->response_code()); |
642 EXPECT_TRUE(response_.headers->HasHeaderValue("Content-Type", "text/plain")); | 677 EXPECT_TRUE(response_.headers->HasHeaderValue("Content-Type", "text/plain")); |
643 | 678 |
644 // Send the response body. | 679 // Send the response body. |
645 const char kResponseBody[] = "Hello world!"; | 680 const char kResponseBody[] = "Hello world!"; |
646 ProcessPacket(ConstructDataPacket(3, false, kFin, response_data_.length(), | 681 ProcessPacket(ConstructDataPacket(3, false, kFin, response_data_.length(), |
647 kResponseBody)); | 682 kResponseBody)); |
648 | 683 |
649 // The body has arrived, but it is delivered asynchronously | 684 // The body has arrived, but it is delivered asynchronously |
650 ASSERT_EQ(static_cast<int>(strlen(kResponseBody)), | 685 ASSERT_EQ(static_cast<int>(strlen(kResponseBody)), |
651 stream_->ReadResponseBody(read_buffer_.get(), read_buffer_->size(), | 686 stream_->ReadResponseBody(read_buffer_.get(), read_buffer_->size(), |
652 callback_.callback())); | 687 callback_.callback())); |
653 EXPECT_TRUE(stream_->IsResponseBodyComplete()); | 688 EXPECT_TRUE(stream_->IsResponseBodyComplete()); |
654 EXPECT_TRUE(AtEof()); | 689 EXPECT_TRUE(AtEof()); |
655 | 690 |
656 // QuicHttpStream::GetTotalSent/ReceivedBytes currently only includes the | 691 // QuicHttpStream::GetTotalSent/ReceivedBytes currently only includes the |
657 // payload. | 692 // headers and payload. |
658 EXPECT_EQ(static_cast<int64_t>(strlen(kUploadData)), | 693 EXPECT_EQ(static_cast<int64_t>(spdy_request_headers_frame_length + |
| 694 strlen(kUploadData)), |
659 stream_->GetTotalSentBytes()); | 695 stream_->GetTotalSentBytes()); |
660 EXPECT_EQ(static_cast<int64_t>(strlen(kResponseBody)), | 696 EXPECT_EQ(static_cast<int64_t>(spdy_response_headers_frame_length + |
| 697 strlen(kResponseBody)), |
661 stream_->GetTotalReceivedBytes()); | 698 stream_->GetTotalReceivedBytes()); |
662 } | 699 } |
663 | 700 |
664 TEST_P(QuicHttpStreamTest, SendChunkedPostRequestWithOneEmptyDataPacket) { | 701 TEST_P(QuicHttpStreamTest, SendChunkedPostRequestWithOneEmptyDataPacket) { |
665 SetRequest("POST", "/", DEFAULT_PRIORITY); | 702 SetRequest("POST", "/", DEFAULT_PRIORITY); |
666 AddWrite(ConstructRequestHeadersPacket(1, !kFin, DEFAULT_PRIORITY)); | 703 size_t spdy_request_headers_frame_length; |
| 704 AddWrite(ConstructRequestHeadersPacket(1, !kFin, DEFAULT_PRIORITY, |
| 705 &spdy_request_headers_frame_length)); |
667 AddWrite(ConstructDataPacket(2, kIncludeVersion, kFin, 0, "")); | 706 AddWrite(ConstructDataPacket(2, kIncludeVersion, kFin, 0, "")); |
668 AddWrite(ConstructAckPacket(3, 3, 1)); | 707 AddWrite(ConstructAckPacket(3, 3, 1)); |
669 Initialize(); | 708 Initialize(); |
670 | 709 |
671 ChunkedUploadDataStream upload_data_stream(0); | 710 ChunkedUploadDataStream upload_data_stream(0); |
672 | 711 |
673 request_.method = "POST"; | 712 request_.method = "POST"; |
674 request_.url = GURL("http://www.google.com/"); | 713 request_.url = GURL("http://www.google.com/"); |
675 request_.upload_data_stream = &upload_data_stream; | 714 request_.upload_data_stream = &upload_data_stream; |
676 ASSERT_EQ(OK, request_.upload_data_stream->Init( | 715 ASSERT_EQ(OK, request_.upload_data_stream->Init( |
677 TestCompletionCallback().callback())); | 716 TestCompletionCallback().callback())); |
678 | 717 |
679 ASSERT_EQ(OK, stream_->InitializeStream(&request_, DEFAULT_PRIORITY, | 718 ASSERT_EQ(OK, stream_->InitializeStream(&request_, DEFAULT_PRIORITY, |
680 net_log_, callback_.callback())); | 719 net_log_, callback_.callback())); |
681 ASSERT_EQ(ERR_IO_PENDING, stream_->SendRequest(headers_, &response_, | 720 ASSERT_EQ(ERR_IO_PENDING, stream_->SendRequest(headers_, &response_, |
682 callback_.callback())); | 721 callback_.callback())); |
683 | 722 |
684 upload_data_stream.AppendData(nullptr, 0, true); | 723 upload_data_stream.AppendData(nullptr, 0, true); |
685 EXPECT_EQ(OK, callback_.WaitForResult()); | 724 EXPECT_EQ(OK, callback_.WaitForResult()); |
686 | 725 |
687 ProcessPacket(ConstructAckPacket(1, 0, 0)); | 726 ProcessPacket(ConstructAckPacket(1, 0, 0)); |
688 | 727 |
689 // Send the response headers (but not the body). | 728 // Send the response headers (but not the body). |
690 SetResponse("200 OK", std::string()); | 729 SetResponse("200 OK", std::string()); |
691 ProcessPacket(ConstructResponseHeadersPacket(2, !kFin)); | 730 size_t spdy_response_headers_frame_length; |
| 731 ProcessPacket(ConstructResponseHeadersPacket( |
| 732 2, !kFin, &spdy_response_headers_frame_length)); |
692 | 733 |
693 // The headers have arrived, but they are delivered asynchronously | 734 // The headers have arrived, but they are delivered asynchronously |
694 EXPECT_EQ(ERR_IO_PENDING, stream_->ReadResponseHeaders(callback_.callback())); | 735 EXPECT_EQ(ERR_IO_PENDING, stream_->ReadResponseHeaders(callback_.callback())); |
695 EXPECT_EQ(OK, callback_.WaitForResult()); | 736 EXPECT_EQ(OK, callback_.WaitForResult()); |
696 ASSERT_TRUE(response_.headers.get()); | 737 ASSERT_TRUE(response_.headers.get()); |
697 EXPECT_EQ(200, response_.headers->response_code()); | 738 EXPECT_EQ(200, response_.headers->response_code()); |
698 EXPECT_TRUE(response_.headers->HasHeaderValue("Content-Type", "text/plain")); | 739 EXPECT_TRUE(response_.headers->HasHeaderValue("Content-Type", "text/plain")); |
699 | 740 |
700 // Send the response body. | 741 // Send the response body. |
701 const char kResponseBody[] = "Hello world!"; | 742 const char kResponseBody[] = "Hello world!"; |
702 ProcessPacket(ConstructDataPacket(3, false, kFin, response_data_.length(), | 743 ProcessPacket(ConstructDataPacket(3, false, kFin, response_data_.length(), |
703 kResponseBody)); | 744 kResponseBody)); |
704 | 745 |
705 // The body has arrived, but it is delivered asynchronously | 746 // The body has arrived, but it is delivered asynchronously |
706 ASSERT_EQ(static_cast<int>(strlen(kResponseBody)), | 747 ASSERT_EQ(static_cast<int>(strlen(kResponseBody)), |
707 stream_->ReadResponseBody(read_buffer_.get(), read_buffer_->size(), | 748 stream_->ReadResponseBody(read_buffer_.get(), read_buffer_->size(), |
708 callback_.callback())); | 749 callback_.callback())); |
709 | 750 |
710 EXPECT_TRUE(stream_->IsResponseBodyComplete()); | 751 EXPECT_TRUE(stream_->IsResponseBodyComplete()); |
711 EXPECT_TRUE(AtEof()); | 752 EXPECT_TRUE(AtEof()); |
712 | 753 |
713 // QuicHttpStream::GetTotalSent/ReceivedBytes currently only includes the | 754 // QuicHttpStream::GetTotalSent/ReceivedBytes currently only includes the |
714 // payload. | 755 // headers and payload. |
715 EXPECT_EQ(0, stream_->GetTotalSentBytes()); | 756 EXPECT_EQ(static_cast<int64_t>(spdy_request_headers_frame_length), |
716 EXPECT_EQ(static_cast<int64_t>(strlen(kResponseBody)), | 757 stream_->GetTotalSentBytes()); |
| 758 EXPECT_EQ(static_cast<int64_t>(spdy_response_headers_frame_length + |
| 759 strlen(kResponseBody)), |
717 stream_->GetTotalReceivedBytes()); | 760 stream_->GetTotalReceivedBytes()); |
718 } | 761 } |
719 | 762 |
720 TEST_P(QuicHttpStreamTest, DestroyedEarly) { | 763 TEST_P(QuicHttpStreamTest, DestroyedEarly) { |
721 SetRequest("GET", "/", DEFAULT_PRIORITY); | 764 SetRequest("GET", "/", DEFAULT_PRIORITY); |
722 AddWrite(ConstructRequestHeadersPacket(1, kFin, DEFAULT_PRIORITY)); | 765 size_t spdy_request_headers_frame_length; |
| 766 AddWrite(ConstructRequestHeadersPacket(1, kFin, DEFAULT_PRIORITY, |
| 767 &spdy_request_headers_frame_length)); |
723 AddWrite(ConstructAckAndRstStreamPacket(2)); | 768 AddWrite(ConstructAckAndRstStreamPacket(2)); |
724 use_closing_stream_ = true; | 769 use_closing_stream_ = true; |
725 Initialize(); | 770 Initialize(); |
726 | 771 |
727 request_.method = "GET"; | 772 request_.method = "GET"; |
728 request_.url = GURL("http://www.google.com/"); | 773 request_.url = GURL("http://www.google.com/"); |
729 | 774 |
730 EXPECT_EQ(OK, stream_->InitializeStream(&request_, DEFAULT_PRIORITY, | 775 EXPECT_EQ(OK, stream_->InitializeStream(&request_, DEFAULT_PRIORITY, |
731 net_log_, callback_.callback())); | 776 net_log_, callback_.callback())); |
732 EXPECT_EQ(OK, stream_->SendRequest(headers_, &response_, | 777 EXPECT_EQ(OK, stream_->SendRequest(headers_, &response_, |
733 callback_.callback())); | 778 callback_.callback())); |
734 | 779 |
735 // Ack the request. | 780 // Ack the request. |
736 ProcessPacket(ConstructAckPacket(1, 0, 0)); | 781 ProcessPacket(ConstructAckPacket(1, 0, 0)); |
737 EXPECT_EQ(ERR_IO_PENDING, | 782 EXPECT_EQ(ERR_IO_PENDING, |
738 stream_->ReadResponseHeaders(callback_.callback())); | 783 stream_->ReadResponseHeaders(callback_.callback())); |
739 | 784 |
740 // Send the response with a body. | 785 // Send the response with a body. |
741 SetResponse("404 OK", "hello world!"); | 786 SetResponse("404 OK", "hello world!"); |
742 // In the course of processing this packet, the QuicHttpStream close itself. | 787 // In the course of processing this packet, the QuicHttpStream close itself. |
743 ProcessPacket(ConstructResponseHeadersPacket(2, kFin)); | 788 ProcessPacket(ConstructResponseHeadersPacket(2, kFin, nullptr)); |
744 | 789 |
745 base::MessageLoop::current()->RunUntilIdle(); | 790 base::MessageLoop::current()->RunUntilIdle(); |
746 | 791 |
747 EXPECT_TRUE(AtEof()); | 792 EXPECT_TRUE(AtEof()); |
748 | 793 |
749 // QuicHttpStream::GetTotalSent/ReceivedBytes currently only includes the | 794 // QuicHttpStream::GetTotalSent/ReceivedBytes currently only includes the |
750 // payload. | 795 // headers and payload. |
751 EXPECT_EQ(0, stream_->GetTotalSentBytes()); | 796 EXPECT_EQ(static_cast<int64_t>(spdy_request_headers_frame_length), |
| 797 stream_->GetTotalSentBytes()); |
| 798 // Zero since the stream is closed before processing the headers. |
752 EXPECT_EQ(0, stream_->GetTotalReceivedBytes()); | 799 EXPECT_EQ(0, stream_->GetTotalReceivedBytes()); |
753 } | 800 } |
754 | 801 |
755 TEST_P(QuicHttpStreamTest, Priority) { | 802 TEST_P(QuicHttpStreamTest, Priority) { |
756 SetRequest("GET", "/", MEDIUM); | 803 SetRequest("GET", "/", MEDIUM); |
757 AddWrite(ConstructRequestHeadersPacket(1, kFin, MEDIUM)); | 804 size_t spdy_request_headers_frame_length; |
| 805 AddWrite(ConstructRequestHeadersPacket(1, kFin, MEDIUM, |
| 806 &spdy_request_headers_frame_length)); |
758 AddWrite(ConstructAckAndRstStreamPacket(2)); | 807 AddWrite(ConstructAckAndRstStreamPacket(2)); |
759 use_closing_stream_ = true; | 808 use_closing_stream_ = true; |
760 Initialize(); | 809 Initialize(); |
761 | 810 |
762 request_.method = "GET"; | 811 request_.method = "GET"; |
763 request_.url = GURL("http://www.google.com/"); | 812 request_.url = GURL("http://www.google.com/"); |
764 | 813 |
765 EXPECT_EQ(OK, stream_->InitializeStream(&request_, MEDIUM, | 814 EXPECT_EQ(OK, stream_->InitializeStream(&request_, MEDIUM, |
766 net_log_, callback_.callback())); | 815 net_log_, callback_.callback())); |
767 | 816 |
(...skipping 12 matching lines...) Expand all Loading... |
780 reliable_stream->EffectivePriority())); | 829 reliable_stream->EffectivePriority())); |
781 | 830 |
782 // Ack the request. | 831 // Ack the request. |
783 ProcessPacket(ConstructAckPacket(1, 0, 0)); | 832 ProcessPacket(ConstructAckPacket(1, 0, 0)); |
784 EXPECT_EQ(ERR_IO_PENDING, | 833 EXPECT_EQ(ERR_IO_PENDING, |
785 stream_->ReadResponseHeaders(callback_.callback())); | 834 stream_->ReadResponseHeaders(callback_.callback())); |
786 | 835 |
787 // Send the response with a body. | 836 // Send the response with a body. |
788 SetResponse("404 OK", "hello world!"); | 837 SetResponse("404 OK", "hello world!"); |
789 // In the course of processing this packet, the QuicHttpStream close itself. | 838 // In the course of processing this packet, the QuicHttpStream close itself. |
790 ProcessPacket(ConstructResponseHeadersPacket(2, kFin)); | 839 ProcessPacket(ConstructResponseHeadersPacket(2, kFin, nullptr)); |
791 | 840 |
792 base::MessageLoop::current()->RunUntilIdle(); | 841 base::MessageLoop::current()->RunUntilIdle(); |
793 | 842 |
794 EXPECT_TRUE(AtEof()); | 843 EXPECT_TRUE(AtEof()); |
795 | 844 |
796 // QuicHttpStream::GetTotalSent/ReceivedBytes currently only includes the | 845 // QuicHttpStream::GetTotalSent/ReceivedBytes currently only includes the |
797 // payload. | 846 // headers and payload. |
798 EXPECT_EQ(0, stream_->GetTotalSentBytes()); | 847 EXPECT_EQ(static_cast<int64_t>(spdy_request_headers_frame_length), |
| 848 stream_->GetTotalSentBytes()); |
| 849 // Zero since the stream is closed before processing the headers. |
799 EXPECT_EQ(0, stream_->GetTotalReceivedBytes()); | 850 EXPECT_EQ(0, stream_->GetTotalReceivedBytes()); |
800 } | 851 } |
801 | 852 |
802 // Regression test for http://crbug.com/294870 | 853 // Regression test for http://crbug.com/294870 |
803 TEST_P(QuicHttpStreamTest, CheckPriorityWithNoDelegate) { | 854 TEST_P(QuicHttpStreamTest, CheckPriorityWithNoDelegate) { |
804 SetRequest("GET", "/", MEDIUM); | 855 SetRequest("GET", "/", MEDIUM); |
805 use_closing_stream_ = true; | 856 use_closing_stream_ = true; |
806 | 857 |
807 AddWrite(ConstructRstStreamPacket(1)); | 858 AddWrite(ConstructRstStreamPacket(1)); |
808 | 859 |
(...skipping 14 matching lines...) Expand all Loading... |
823 DCHECK_EQ(QuicWriteBlockedList::kHighestPriority, | 874 DCHECK_EQ(QuicWriteBlockedList::kHighestPriority, |
824 reliable_stream->EffectivePriority()); | 875 reliable_stream->EffectivePriority()); |
825 | 876 |
826 // Set Delegate to nullptr and make sure EffectivePriority returns highest | 877 // Set Delegate to nullptr and make sure EffectivePriority returns highest |
827 // priority. | 878 // priority. |
828 reliable_stream->SetDelegate(nullptr); | 879 reliable_stream->SetDelegate(nullptr); |
829 DCHECK_EQ(QuicWriteBlockedList::kHighestPriority, | 880 DCHECK_EQ(QuicWriteBlockedList::kHighestPriority, |
830 reliable_stream->EffectivePriority()); | 881 reliable_stream->EffectivePriority()); |
831 reliable_stream->SetDelegate(delegate); | 882 reliable_stream->SetDelegate(delegate); |
832 | 883 |
833 // QuicHttpStream::GetTotalSent/ReceivedBytes currently only includes the | |
834 // payload. | |
835 EXPECT_EQ(0, stream_->GetTotalSentBytes()); | 884 EXPECT_EQ(0, stream_->GetTotalSentBytes()); |
836 EXPECT_EQ(0, stream_->GetTotalReceivedBytes()); | 885 EXPECT_EQ(0, stream_->GetTotalReceivedBytes()); |
837 } | 886 } |
838 | 887 |
839 } // namespace test | 888 } // namespace test |
840 } // namespace net | 889 } // namespace net |
OLD | NEW |