spdy_stream_test_util.cc 6.0 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203
  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. #include "net/spdy/spdy_stream_test_util.h"
  5. #include <cstddef>
  6. #include <utility>
  7. #include "base/strings/string_piece.h"
  8. #include "net/spdy/spdy_stream.h"
  9. #include "testing/gtest/include/gtest/gtest.h"
  10. namespace net::test {
  11. ClosingDelegate::ClosingDelegate(
  12. const base::WeakPtr<SpdyStream>& stream) : stream_(stream) {
  13. DCHECK(stream_);
  14. }
  15. ClosingDelegate::~ClosingDelegate() = default;
  16. void ClosingDelegate::OnHeadersSent() {}
  17. void ClosingDelegate::OnEarlyHintsReceived(
  18. const spdy::Http2HeaderBlock& headers) {}
  19. void ClosingDelegate::OnHeadersReceived(
  20. const spdy::Http2HeaderBlock& response_headers,
  21. const spdy::Http2HeaderBlock* pushed_request_headers) {}
  22. void ClosingDelegate::OnDataReceived(std::unique_ptr<SpdyBuffer> buffer) {}
  23. void ClosingDelegate::OnDataSent() {}
  24. void ClosingDelegate::OnTrailers(const spdy::Http2HeaderBlock& trailers) {}
  25. void ClosingDelegate::OnClose(int status) {
  26. DCHECK(stream_);
  27. stream_->Close();
  28. // The |stream_| may still be alive (if it is our delegate).
  29. }
  30. bool ClosingDelegate::CanGreaseFrameType() const {
  31. return false;
  32. }
  33. NetLogSource ClosingDelegate::source_dependency() const {
  34. return NetLogSource();
  35. }
  36. StreamDelegateBase::StreamDelegateBase(const base::WeakPtr<SpdyStream>& stream)
  37. : stream_(stream) {}
  38. StreamDelegateBase::~StreamDelegateBase() = default;
  39. void StreamDelegateBase::OnHeadersSent() {
  40. stream_id_ = stream_->stream_id();
  41. EXPECT_NE(stream_id_, 0u);
  42. send_headers_completed_ = true;
  43. }
  44. void StreamDelegateBase::OnEarlyHintsReceived(
  45. const spdy::Http2HeaderBlock& headers) {
  46. EXPECT_EQ(stream_->type() != SPDY_PUSH_STREAM, send_headers_completed_);
  47. early_hints_.push_back(headers.Clone());
  48. }
  49. void StreamDelegateBase::OnHeadersReceived(
  50. const spdy::Http2HeaderBlock& response_headers,
  51. const spdy::Http2HeaderBlock* pushed_request_headers) {
  52. EXPECT_EQ(stream_->type() != SPDY_PUSH_STREAM, send_headers_completed_);
  53. response_headers_ = response_headers.Clone();
  54. }
  55. void StreamDelegateBase::OnDataReceived(std::unique_ptr<SpdyBuffer> buffer) {
  56. if (buffer)
  57. received_data_queue_.Enqueue(std::move(buffer));
  58. }
  59. void StreamDelegateBase::OnDataSent() {}
  60. void StreamDelegateBase::OnTrailers(const spdy::Http2HeaderBlock& trailers) {}
  61. void StreamDelegateBase::OnClose(int status) {
  62. if (!stream_.get())
  63. return;
  64. stream_id_ = stream_->stream_id();
  65. stream_->GetLoadTimingInfo(&load_timing_info_);
  66. stream_.reset();
  67. callback_.callback().Run(status);
  68. }
  69. bool StreamDelegateBase::CanGreaseFrameType() const {
  70. return false;
  71. }
  72. NetLogSource StreamDelegateBase::source_dependency() const {
  73. return NetLogSource();
  74. }
  75. int StreamDelegateBase::WaitForClose() {
  76. int result = callback_.WaitForResult();
  77. EXPECT_TRUE(!stream_.get());
  78. return result;
  79. }
  80. std::string StreamDelegateBase::TakeReceivedData() {
  81. size_t len = received_data_queue_.GetTotalSize();
  82. std::string received_data(len, '\0');
  83. if (len > 0) {
  84. EXPECT_EQ(len, received_data_queue_.Dequeue(std::data(received_data), len));
  85. }
  86. return received_data;
  87. }
  88. std::string StreamDelegateBase::GetResponseHeaderValue(
  89. const std::string& name) const {
  90. spdy::Http2HeaderBlock::const_iterator it = response_headers_.find(name);
  91. return (it == response_headers_.end()) ? std::string()
  92. : std::string(it->second);
  93. }
  94. const LoadTimingInfo& StreamDelegateBase::GetLoadTimingInfo() {
  95. DCHECK(StreamIsClosed());
  96. return load_timing_info_;
  97. }
  98. StreamDelegateDoNothing::StreamDelegateDoNothing(
  99. const base::WeakPtr<SpdyStream>& stream)
  100. : StreamDelegateBase(stream) {}
  101. StreamDelegateDoNothing::~StreamDelegateDoNothing() = default;
  102. StreamDelegateConsumeData::StreamDelegateConsumeData(
  103. const base::WeakPtr<SpdyStream>& stream)
  104. : StreamDelegateBase(stream) {}
  105. StreamDelegateConsumeData::~StreamDelegateConsumeData() = default;
  106. void StreamDelegateConsumeData::OnDataReceived(
  107. std::unique_ptr<SpdyBuffer> buffer) {
  108. buffer->Consume(buffer->GetRemainingSize());
  109. }
  110. StreamDelegateSendImmediate::StreamDelegateSendImmediate(
  111. const base::WeakPtr<SpdyStream>& stream,
  112. base::StringPiece data)
  113. : StreamDelegateBase(stream), data_(data) {}
  114. StreamDelegateSendImmediate::~StreamDelegateSendImmediate() = default;
  115. void StreamDelegateSendImmediate::OnHeadersReceived(
  116. const spdy::Http2HeaderBlock& response_headers,
  117. const spdy::Http2HeaderBlock* pushed_request_headers) {
  118. StreamDelegateBase::OnHeadersReceived(response_headers,
  119. pushed_request_headers);
  120. if (data_.data()) {
  121. scoped_refptr<StringIOBuffer> buf =
  122. base::MakeRefCounted<StringIOBuffer>(std::string(data_));
  123. stream()->SendData(buf.get(), buf->size(), MORE_DATA_TO_SEND);
  124. }
  125. }
  126. StreamDelegateWithBody::StreamDelegateWithBody(
  127. const base::WeakPtr<SpdyStream>& stream,
  128. base::StringPiece data)
  129. : StreamDelegateBase(stream),
  130. buf_(base::MakeRefCounted<StringIOBuffer>(std::string(data))) {}
  131. StreamDelegateWithBody::~StreamDelegateWithBody() = default;
  132. void StreamDelegateWithBody::OnHeadersSent() {
  133. StreamDelegateBase::OnHeadersSent();
  134. stream()->SendData(buf_.get(), buf_->size(), NO_MORE_DATA_TO_SEND);
  135. }
  136. StreamDelegateCloseOnHeaders::StreamDelegateCloseOnHeaders(
  137. const base::WeakPtr<SpdyStream>& stream)
  138. : StreamDelegateBase(stream) {
  139. }
  140. StreamDelegateCloseOnHeaders::~StreamDelegateCloseOnHeaders() = default;
  141. void StreamDelegateCloseOnHeaders::OnHeadersReceived(
  142. const spdy::Http2HeaderBlock& response_headers,
  143. const spdy::Http2HeaderBlock* pushed_request_headers) {
  144. stream()->Cancel(ERR_ABORTED);
  145. }
  146. StreamDelegateDetectEOF::StreamDelegateDetectEOF(
  147. const base::WeakPtr<SpdyStream>& stream)
  148. : StreamDelegateBase(stream) {}
  149. StreamDelegateDetectEOF::~StreamDelegateDetectEOF() = default;
  150. void StreamDelegateDetectEOF::OnDataReceived(
  151. std::unique_ptr<SpdyBuffer> buffer) {
  152. if (!buffer)
  153. eof_detected_ = true;
  154. }
  155. } // namespace net::test