Add more BrotliFilter information to UMA.

net/filter/brotli_filter.cc

 // 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) {
+        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);
   }
 
@@ skipping 22 matching lines @@
       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);
@@ skipping 70 matching lines @@
   // 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