brotli_source_stream.cc 6.2 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183
  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/brotli_source_stream.h"
  5. #include "base/bind.h"
  6. #include "base/bit_cast.h"
  7. #include "base/check_op.h"
  8. #include "base/memory/raw_ptr.h"
  9. #include "base/metrics/histogram_macros.h"
  10. #include "net/base/io_buffer.h"
  11. #include "third_party/brotli/include/brotli/decode.h"
  12. namespace net {
  13. namespace {
  14. const char kBrotli[] = "BROTLI";
  15. // BrotliSourceStream applies Brotli content decoding to a data stream.
  16. // Brotli format specification: http://www.ietf.org/id/draft-alakuijala-brotli.
  17. class BrotliSourceStream : public FilterSourceStream {
  18. public:
  19. explicit BrotliSourceStream(std::unique_ptr<SourceStream> upstream)
  20. : FilterSourceStream(SourceStream::TYPE_BROTLI, std::move(upstream)) {
  21. brotli_state_ =
  22. BrotliDecoderCreateInstance(AllocateMemory, FreeMemory, this);
  23. CHECK(brotli_state_);
  24. }
  25. BrotliSourceStream(const BrotliSourceStream&) = delete;
  26. BrotliSourceStream& operator=(const BrotliSourceStream&) = delete;
  27. ~BrotliSourceStream() override {
  28. BrotliDecoderErrorCode error_code =
  29. BrotliDecoderGetErrorCode(brotli_state_);
  30. BrotliDecoderDestroyInstance(brotli_state_);
  31. brotli_state_ = nullptr;
  32. DCHECK_EQ(0u, used_memory_);
  33. UMA_HISTOGRAM_ENUMERATION(
  34. "BrotliFilter.Status", static_cast<int>(decoding_status_),
  35. static_cast<int>(DecodingStatus::DECODING_STATUS_COUNT));
  36. if (decoding_status_ == DecodingStatus::DECODING_DONE) {
  37. // CompressionPercent is undefined when there is no output produced.
  38. if (produced_bytes_ != 0) {
  39. UMA_HISTOGRAM_PERCENTAGE(
  40. "BrotliFilter.CompressionPercent",
  41. static_cast<int>((consumed_bytes_ * 100) / produced_bytes_));
  42. }
  43. }
  44. if (error_code < 0) {
  45. UMA_HISTOGRAM_ENUMERATION("BrotliFilter.ErrorCode",
  46. -static_cast<int>(error_code),
  47. 1 - BROTLI_LAST_ERROR_CODE);
  48. }
  49. // All code here is for gathering stats, and can be removed when
  50. // BrotliSourceStream is considered stable.
  51. const int kBuckets = 48;
  52. const int64_t kMaxKb = 1 << (kBuckets / 3); // 64MiB in KiB
  53. UMA_HISTOGRAM_CUSTOM_COUNTS("BrotliFilter.UsedMemoryKB",
  54. used_memory_maximum_ / 1024, 1, kMaxKb,
  55. kBuckets);
  56. }
  57. private:
  58. // Reported in UMA and must be kept in sync with the histograms.xml file.
  59. enum class DecodingStatus : int {
  60. DECODING_IN_PROGRESS = 0,
  61. DECODING_DONE,
  62. DECODING_ERROR,
  63. DECODING_STATUS_COUNT
  64. // DECODING_STATUS_COUNT must always be the last element in this enum.
  65. };
  66. // SourceStream implementation
  67. std::string GetTypeAsString() const override { return kBrotli; }
  68. base::expected<size_t, Error> FilterData(
  69. IOBuffer* output_buffer,
  70. size_t output_buffer_size,
  71. IOBuffer* input_buffer,
  72. size_t input_buffer_size,
  73. size_t* consumed_bytes,
  74. bool /*upstream_eof_reached*/) override {
  75. if (decoding_status_ == DecodingStatus::DECODING_DONE) {
  76. *consumed_bytes = input_buffer_size;
  77. return 0;
  78. }
  79. if (decoding_status_ != DecodingStatus::DECODING_IN_PROGRESS)
  80. return base::unexpected(ERR_CONTENT_DECODING_FAILED);
  81. const uint8_t* next_in = base::bit_cast<uint8_t*>(input_buffer->data());
  82. size_t available_in = input_buffer_size;
  83. uint8_t* next_out = base::bit_cast<uint8_t*>(output_buffer->data());
  84. size_t available_out = output_buffer_size;
  85. BrotliDecoderResult result =
  86. BrotliDecoderDecompressStream(brotli_state_, &available_in, &next_in,
  87. &available_out, &next_out, nullptr);
  88. size_t bytes_used = input_buffer_size - available_in;
  89. size_t bytes_written = output_buffer_size - available_out;
  90. CHECK_GE(input_buffer_size, available_in);
  91. CHECK_GE(output_buffer_size, available_out);
  92. produced_bytes_ += bytes_written;
  93. consumed_bytes_ += bytes_used;
  94. *consumed_bytes = bytes_used;
  95. switch (result) {
  96. case BROTLI_DECODER_RESULT_NEEDS_MORE_OUTPUT:
  97. return bytes_written;
  98. case BROTLI_DECODER_RESULT_SUCCESS:
  99. decoding_status_ = DecodingStatus::DECODING_DONE;
  100. // Consume remaining bytes to avoid DCHECK in FilterSourceStream.
  101. // See crbug.com/659311.
  102. *consumed_bytes = input_buffer_size;
  103. return bytes_written;
  104. case BROTLI_DECODER_RESULT_NEEDS_MORE_INPUT:
  105. // Decompress needs more input has consumed all existing input.
  106. DCHECK_EQ(*consumed_bytes, input_buffer_size);
  107. decoding_status_ = DecodingStatus::DECODING_IN_PROGRESS;
  108. return bytes_written;
  109. // If the decompressor threw an error, fail synchronously.
  110. default:
  111. decoding_status_ = DecodingStatus::DECODING_ERROR;
  112. return base::unexpected(ERR_CONTENT_DECODING_FAILED);
  113. }
  114. }
  115. static void* AllocateMemory(void* opaque, size_t size) {
  116. BrotliSourceStream* filter = reinterpret_cast<BrotliSourceStream*>(opaque);
  117. return filter->AllocateMemoryInternal(size);
  118. }
  119. static void FreeMemory(void* opaque, void* address) {
  120. BrotliSourceStream* filter = reinterpret_cast<BrotliSourceStream*>(opaque);
  121. filter->FreeMemoryInternal(address);
  122. }
  123. void* AllocateMemoryInternal(size_t size) {
  124. size_t* array = reinterpret_cast<size_t*>(malloc(size + sizeof(size_t)));
  125. if (!array)
  126. return nullptr;
  127. used_memory_ += size;
  128. if (used_memory_maximum_ < used_memory_)
  129. used_memory_maximum_ = used_memory_;
  130. array[0] = size;
  131. return &array[1];
  132. }
  133. void FreeMemoryInternal(void* address) {
  134. if (!address)
  135. return;
  136. size_t* array = reinterpret_cast<size_t*>(address);
  137. used_memory_ -= array[-1];
  138. free(&array[-1]);
  139. }
  140. raw_ptr<BrotliDecoderState> brotli_state_;
  141. DecodingStatus decoding_status_ = DecodingStatus::DECODING_IN_PROGRESS;
  142. size_t used_memory_ = 0;
  143. size_t used_memory_maximum_ = 0;
  144. size_t consumed_bytes_ = 0;
  145. size_t produced_bytes_ = 0;
  146. };
  147. } // namespace
  148. std::unique_ptr<FilterSourceStream> CreateBrotliSourceStream(
  149. std::unique_ptr<SourceStream> previous) {
  150. return std::make_unique<BrotliSourceStream>(std::move(previous));
  151. }
  152. } // namespace net