filter_source_stream.cc 6.0 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208
  1. // Copyright 2016 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/filter/filter_source_stream.h"
  5. #include <utility>
  6. #include "base/bind.h"
  7. #include "base/check_op.h"
  8. #include "base/metrics/histogram_macros.h"
  9. #include "base/notreached.h"
  10. #include "base/numerics/safe_conversions.h"
  11. #include "base/strings/string_util.h"
  12. #include "net/base/features.h"
  13. #include "net/base/io_buffer.h"
  14. #include "net/base/net_errors.h"
  15. namespace net {
  16. namespace {
  17. const char kDeflate[] = "deflate";
  18. const char kGZip[] = "gzip";
  19. const char kXGZip[] = "x-gzip";
  20. const char kBrotli[] = "br";
  21. } // namespace
  22. FilterSourceStream::FilterSourceStream(SourceType type,
  23. std::unique_ptr<SourceStream> upstream)
  24. : SourceStream(type), upstream_(std::move(upstream)) {
  25. DCHECK(upstream_);
  26. }
  27. FilterSourceStream::~FilterSourceStream() = default;
  28. int FilterSourceStream::Read(IOBuffer* read_buffer,
  29. int read_buffer_size,
  30. CompletionOnceCallback callback) {
  31. DCHECK_EQ(STATE_NONE, next_state_);
  32. DCHECK(read_buffer);
  33. DCHECK_LT(0, read_buffer_size);
  34. // Allocate a BlockBuffer during first Read().
  35. if (!input_buffer_) {
  36. input_buffer_ = base::MakeRefCounted<IOBufferWithSize>(
  37. net::features::kOptimizeNetworkBuffersFilterSourceStreamBufferSize
  38. .Get());
  39. // This is first Read(), start with reading data from |upstream_|.
  40. next_state_ = STATE_READ_DATA;
  41. } else {
  42. // Otherwise start with filtering data, which will tell us whether this
  43. // stream needs input data.
  44. next_state_ = STATE_FILTER_DATA;
  45. }
  46. output_buffer_ = read_buffer;
  47. output_buffer_size_ = base::checked_cast<size_t>(read_buffer_size);
  48. int rv = DoLoop(OK);
  49. if (rv == ERR_IO_PENDING)
  50. callback_ = std::move(callback);
  51. return rv;
  52. }
  53. std::string FilterSourceStream::Description() const {
  54. std::string next_type_string = upstream_->Description();
  55. if (next_type_string.empty())
  56. return GetTypeAsString();
  57. return next_type_string + "," + GetTypeAsString();
  58. }
  59. bool FilterSourceStream::MayHaveMoreBytes() const {
  60. return !upstream_end_reached_;
  61. }
  62. FilterSourceStream::SourceType FilterSourceStream::ParseEncodingType(
  63. const std::string& encoding) {
  64. if (encoding.empty()) {
  65. return TYPE_NONE;
  66. } else if (base::EqualsCaseInsensitiveASCII(encoding, kBrotli)) {
  67. return TYPE_BROTLI;
  68. } else if (base::EqualsCaseInsensitiveASCII(encoding, kDeflate)) {
  69. return TYPE_DEFLATE;
  70. } else if (base::EqualsCaseInsensitiveASCII(encoding, kGZip) ||
  71. base::EqualsCaseInsensitiveASCII(encoding, kXGZip)) {
  72. return TYPE_GZIP;
  73. } else {
  74. return TYPE_UNKNOWN;
  75. }
  76. }
  77. int FilterSourceStream::DoLoop(int result) {
  78. DCHECK_NE(STATE_NONE, next_state_);
  79. int rv = result;
  80. do {
  81. State state = next_state_;
  82. next_state_ = STATE_NONE;
  83. switch (state) {
  84. case STATE_READ_DATA:
  85. rv = DoReadData();
  86. break;
  87. case STATE_READ_DATA_COMPLETE:
  88. rv = DoReadDataComplete(rv);
  89. break;
  90. case STATE_FILTER_DATA:
  91. DCHECK_LE(0, rv);
  92. rv = DoFilterData();
  93. break;
  94. default:
  95. NOTREACHED() << "bad state: " << state;
  96. rv = ERR_UNEXPECTED;
  97. break;
  98. }
  99. } while (rv != ERR_IO_PENDING && next_state_ != STATE_NONE);
  100. return rv;
  101. }
  102. int FilterSourceStream::DoReadData() {
  103. // Read more data means subclasses have consumed all input or this is the
  104. // first read in which case the |drainable_input_buffer_| is not initialized.
  105. DCHECK(drainable_input_buffer_ == nullptr ||
  106. 0 == drainable_input_buffer_->BytesRemaining());
  107. next_state_ = STATE_READ_DATA_COMPLETE;
  108. // Use base::Unretained here is safe because |this| owns |upstream_|.
  109. int rv = upstream_->Read(
  110. input_buffer_.get(),
  111. net::features::kOptimizeNetworkBuffersFilterSourceStreamBufferSize.Get(),
  112. base::BindOnce(&FilterSourceStream::OnIOComplete,
  113. base::Unretained(this)));
  114. return rv;
  115. }
  116. int FilterSourceStream::DoReadDataComplete(int result) {
  117. DCHECK_NE(ERR_IO_PENDING, result);
  118. if (result >= OK) {
  119. drainable_input_buffer_ =
  120. base::MakeRefCounted<DrainableIOBuffer>(input_buffer_, result);
  121. next_state_ = STATE_FILTER_DATA;
  122. }
  123. if (result <= OK)
  124. upstream_end_reached_ = true;
  125. return result;
  126. }
  127. int FilterSourceStream::DoFilterData() {
  128. DCHECK(output_buffer_);
  129. DCHECK(drainable_input_buffer_);
  130. size_t consumed_bytes = 0;
  131. base::expected<size_t, Error> bytes_output = FilterData(
  132. output_buffer_.get(), output_buffer_size_, drainable_input_buffer_.get(),
  133. drainable_input_buffer_->BytesRemaining(), &consumed_bytes,
  134. upstream_end_reached_);
  135. const auto bytes_remaining =
  136. base::checked_cast<size_t>(drainable_input_buffer_->BytesRemaining());
  137. if (bytes_output.has_value() && bytes_output.value() == 0) {
  138. DCHECK_EQ(consumed_bytes, bytes_remaining);
  139. } else {
  140. DCHECK_LE(consumed_bytes, bytes_remaining);
  141. }
  142. // FilterData() is not allowed to return ERR_IO_PENDING.
  143. if (!bytes_output.has_value())
  144. DCHECK_NE(ERR_IO_PENDING, bytes_output.error());
  145. if (consumed_bytes > 0)
  146. drainable_input_buffer_->DidConsume(consumed_bytes);
  147. // Received data or encountered an error.
  148. if (!bytes_output.has_value()) {
  149. CHECK_LT(bytes_output.error(), 0);
  150. return bytes_output.error();
  151. }
  152. if (bytes_output.value() != 0)
  153. return base::checked_cast<int>(bytes_output.value());
  154. // If no data is returned, continue reading if |this| needs more input.
  155. if (NeedMoreData()) {
  156. DCHECK_EQ(0, drainable_input_buffer_->BytesRemaining());
  157. next_state_ = STATE_READ_DATA;
  158. }
  159. return 0;
  160. }
  161. void FilterSourceStream::OnIOComplete(int result) {
  162. DCHECK_EQ(STATE_READ_DATA_COMPLETE, next_state_);
  163. int rv = DoLoop(result);
  164. if (rv == ERR_IO_PENDING)
  165. return;
  166. output_buffer_ = nullptr;
  167. output_buffer_size_ = 0;
  168. std::move(callback_).Run(rv);
  169. }
  170. bool FilterSourceStream::NeedMoreData() const {
  171. return !upstream_end_reached_;
  172. }
  173. } // namespace net