Index: net/filter/brotli_filter.cc |
diff --git a/net/filter/brotli_filter.cc b/net/filter/brotli_filter.cc |
deleted file mode 100644 |
index 41f507c6d45fcf8073398d02dfef017673ede078..0000000000000000000000000000000000000000 |
--- a/net/filter/brotli_filter.cc |
+++ /dev/null |
@@ -1,218 +0,0 @@ |
-// Copyright 2015 The Chromium Authors. All rights reserved. |
-// Use of this source code is governed by a BSD-style license that can be |
-// found in the LICENSE file. |
- |
-#include "net/filter/brotli_filter.h" |
- |
-#include "base/bit_cast.h" |
-#include "base/macros.h" |
-#include "base/metrics/histogram_macros.h" |
-#include "base/numerics/safe_conversions.h" |
-#include "base/numerics/safe_math.h" |
-#include "third_party/brotli/dec/decode.h" |
- |
-namespace net { |
- |
-namespace { |
-const uint8_t kGzipHeader[] = {0x1f, 0x8b, 0x08}; |
-} |
- |
-// BrotliFilter applies Brotli content decoding to a data stream. |
-// Brotli format specification: http://www.ietf.org/id/draft-alakuijala-brotli |
-// |
-// BrotliFilter is a subclass of Filter. See the latter's header file filter.h |
-// for sample usage. |
-class BrotliFilter : public Filter { |
- public: |
- BrotliFilter(FilterType type) |
- : Filter(type), |
- decoding_status_(DecodingStatus::DECODING_IN_PROGRESS), |
- used_memory_(0), |
- used_memory_maximum_(0), |
- consumed_bytes_(0), |
- produced_bytes_(0), |
- gzip_header_detected_(true) { |
- brotli_state_ = BrotliCreateState(BrotliFilter::AllocateMemory, |
- BrotliFilter::FreeMemory, this); |
- CHECK(brotli_state_); |
- } |
- |
- ~BrotliFilter() override { |
- BrotliErrorCode error_code = BrotliGetErrorCode(brotli_state_); |
- BrotliDestroyState(brotli_state_); |
- brotli_state_ = nullptr; |
- DCHECK(used_memory_ == 0); |
- |
- // Don't report that gzip header was detected in case of lack of input. |
- gzip_header_detected_ &= (consumed_bytes_ >= sizeof(kGzipHeader)); |
- |
- UMA_HISTOGRAM_ENUMERATION( |
- "BrotliFilter.Status", static_cast<int>(decoding_status_), |
- static_cast<int>(DecodingStatus::DECODING_STATUS_COUNT)); |
- UMA_HISTOGRAM_BOOLEAN("BrotliFilter.GzipHeaderDetected", |
- gzip_header_detected_); |
- if (decoding_status_ == DecodingStatus::DECODING_DONE) { |
- // CompressionPercent is undefined when there is no output produced. |
- if (produced_bytes_ != 0) { |
- UMA_HISTOGRAM_PERCENTAGE( |
- "BrotliFilter.CompressionPercent", |
- static_cast<int>((consumed_bytes_ * 100) / produced_bytes_)); |
- } |
- } |
- if (error_code < 0) { |
- UMA_HISTOGRAM_ENUMERATION("BrotliFilter.ErrorCode", |
- -static_cast<int>(error_code), |
- 1 - BROTLI_LAST_ERROR_CODE); |
- } |
- |
- // All code here is for gathering stats, and can be removed when |
- // BrotliFilter is considered stable. |
- static const int kBuckets = 48; |
- static const int64_t kMaxKb = 1 << (kBuckets / 3); // 64MiB in KiB |
- UMA_HISTOGRAM_CUSTOM_COUNTS("BrotliFilter.UsedMemoryKB", |
- used_memory_maximum_ / 1024, 1, kMaxKb, |
- kBuckets); |
- } |
- |
- // Decodes the pre-filter data and writes the output into the |dest_buffer| |
- // passed in. |
- // The function returns FilterStatus. See filter.h for its description. |
- // |
- // Upon entry, |*dest_len| is the total size (in number of chars) of the |
- // destination buffer. Upon exit, |*dest_len| is the actual number of chars |
- // written into the destination buffer. |
- // |
- // This function will fail if there is no pre-filter data in the |
- // |stream_buffer_|. On the other hand, |*dest_len| can be 0 upon successful |
- // return. For example, decompressor may process some pre-filter data |
- // but not produce output yet. |
- FilterStatus ReadFilteredData(char* dest_buffer, int* dest_len) override { |
- if (!dest_buffer || !dest_len) |
- return Filter::FILTER_ERROR; |
- |
- if (decoding_status_ == DecodingStatus::DECODING_DONE) { |
- *dest_len = 0; |
- return Filter::FILTER_DONE; |
- } |
- |
- if (decoding_status_ != DecodingStatus::DECODING_IN_PROGRESS) |
- return Filter::FILTER_ERROR; |
- |
- size_t output_buffer_size = base::checked_cast<size_t>(*dest_len); |
- size_t input_buffer_size = base::checked_cast<size_t>(stream_data_len_); |
- |
- size_t available_in = input_buffer_size; |
- const uint8_t* next_in = bit_cast<uint8_t*>(next_stream_data_); |
- size_t available_out = output_buffer_size; |
- uint8_t* next_out = bit_cast<uint8_t*>(dest_buffer); |
- size_t total_out = 0; |
- |
- // Check if start of the input stream looks like gzip stream. |
- for (size_t i = consumed_bytes_; i < sizeof(kGzipHeader); ++i) { |
- if (!gzip_header_detected_) |
- break; |
- size_t j = i - consumed_bytes_; |
- if (j < available_in && kGzipHeader[i] != next_in[j]) |
- gzip_header_detected_ = false; |
- } |
- |
- BrotliResult result = |
- BrotliDecompressStream(&available_in, &next_in, &available_out, |
- &next_out, &total_out, brotli_state_); |
- |
- CHECK(available_in <= input_buffer_size); |
- CHECK(available_out <= output_buffer_size); |
- consumed_bytes_ += input_buffer_size - available_in; |
- produced_bytes_ += output_buffer_size - available_out; |
- |
- base::CheckedNumeric<size_t> safe_bytes_written(output_buffer_size); |
- safe_bytes_written -= available_out; |
- int bytes_written = |
- base::checked_cast<int>(safe_bytes_written.ValueOrDie()); |
- |
- switch (result) { |
- case BROTLI_RESULT_NEEDS_MORE_OUTPUT: |
- // Fall through. |
- case BROTLI_RESULT_SUCCESS: |
- *dest_len = bytes_written; |
- stream_data_len_ = base::checked_cast<int>(available_in); |
- next_stream_data_ = bit_cast<char*>(next_in); |
- if (result == BROTLI_RESULT_SUCCESS) { |
- decoding_status_ = DecodingStatus::DECODING_DONE; |
- return Filter::FILTER_DONE; |
- } |
- return Filter::FILTER_OK; |
- |
- case BROTLI_RESULT_NEEDS_MORE_INPUT: |
- *dest_len = bytes_written; |
- stream_data_len_ = 0; |
- next_stream_data_ = nullptr; |
- return Filter::FILTER_NEED_MORE_DATA; |
- |
- default: |
- decoding_status_ = DecodingStatus::DECODING_ERROR; |
- return Filter::FILTER_ERROR; |
- } |
- } |
- |
- private: |
- static void* AllocateMemory(void* opaque, size_t size) { |
- BrotliFilter* filter = reinterpret_cast<BrotliFilter*>(opaque); |
- return filter->AllocateMemoryInternal(size); |
- } |
- |
- static void FreeMemory(void* opaque, void* address) { |
- BrotliFilter* filter = reinterpret_cast<BrotliFilter*>(opaque); |
- filter->FreeMemoryInternal(address); |
- } |
- |
- void* AllocateMemoryInternal(size_t size) { |
- size_t* array = reinterpret_cast<size_t*>(malloc(size + sizeof(size_t))); |
- if (!array) |
- return nullptr; |
- used_memory_ += size; |
- if (used_memory_maximum_ < used_memory_) |
- used_memory_maximum_ = used_memory_; |
- array[0] = size; |
- return &array[1]; |
- } |
- |
- void FreeMemoryInternal(void* address) { |
- if (!address) |
- return; |
- size_t* array = reinterpret_cast<size_t*>(address); |
- used_memory_ -= array[-1]; |
- free(&array[-1]); |
- } |
- |
- // Reported in UMA and must be kept in sync with the histograms.xml file. |
- enum class DecodingStatus : int { |
- DECODING_IN_PROGRESS = 0, |
- DECODING_DONE, |
- DECODING_ERROR, |
- |
- DECODING_STATUS_COUNT |
- // DECODING_STATUS_COUNT must always be the last element in this enum. |
- }; |
- |
- // Tracks the status of decoding. |
- // This variable is updated only by ReadFilteredData. |
- DecodingStatus decoding_status_; |
- |
- BrotliState* brotli_state_; |
- |
- size_t used_memory_; |
- size_t used_memory_maximum_; |
- size_t consumed_bytes_; |
- size_t produced_bytes_; |
- |
- bool gzip_header_detected_; |
- |
- DISALLOW_COPY_AND_ASSIGN(BrotliFilter); |
-}; |
- |
-Filter* CreateBrotliFilter(Filter::FilterType type_id) { |
- return new BrotliFilter(type_id); |
-} |
- |
-} // namespace net |