Reject unadvertised encodings

net/filter/filter_source_stream.cc

 // Copyright 2016 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/filter_source_stream.h"
 
 #include "base/bind.h"
 #include "base/callback_helpers.h"
 #include "base/logging.h"
 #include "base/metrics/histogram_macros.h"
 #include "base/numerics/safe_conversions.h"
 #include "base/strings/string_util.h"
 #include "net/base/io_buffer.h"
 #include "net/base/net_errors.h"
 
 namespace net {
 
 namespace {
 
+const char kDeflate[] = "deflate";
+const char kGZip[] = "gzip";
+const char kSdch[] = "sdch";
+const char kXGZip[] = "x-gzip";
+const char kBrotli[] = "br";
+
 const size_t kBufferSize = 32 * 1024;
 
 }  // namespace
 
 FilterSourceStream::FilterSourceStream(SourceType type,
                                        std::unique_ptr<SourceStream> upstream)
     : SourceStream(type),
       upstream_(std::move(upstream)),
       next_state_(STATE_NONE),
       output_buffer_size_(0),
@@ skipping 30 matching lines @@
   return rv;
 }
 
 std::string FilterSourceStream::Description() const {
   std::string next_type_string = upstream_->Description();
   if (next_type_string.empty())
     return GetTypeAsString();
   return next_type_string + "," + GetTypeAsString();
 }
 
+FilterSourceStream::SourceType FilterSourceStream::ParseEncodingType(
+    const std::string& encoding) {
+  if (encoding.empty()) {
+    return TYPE_NONE;
+  } else if (base::LowerCaseEqualsASCII(encoding, kBrotli)) {
+    return TYPE_BROTLI;
+  } else if (base::LowerCaseEqualsASCII(encoding, kDeflate)) {
+    return TYPE_DEFLATE;
+  } else if (base::LowerCaseEqualsASCII(encoding, kGZip) ||
+             base::LowerCaseEqualsASCII(encoding, kXGZip)) {
+    return TYPE_GZIP;
+  } else if (base::LowerCaseEqualsASCII(encoding, kSdch)) {
+    return TYPE_SDCH;
+  } else {
+    return TYPE_UNKNOWN;
+  }
+}
+
+void FilterSourceStream::ReportContentDecodingFailed(SourceType type) {
+  UMA_HISTOGRAM_ENUMERATION("Net.ContentDecodingFailed2", type, TYPE_MAX);
+}
+
 int FilterSourceStream::DoLoop(int result) {
   DCHECK_NE(STATE_NONE, next_state_);
 
   int rv = result;
   do {
     State state = next_state_;
     next_state_ = STATE_NONE;
     switch (state) {
       case STATE_READ_DATA:
         rv = DoReadData();
@@ skipping 49 matching lines @@
   int consumed_bytes = 0;
   int bytes_output = FilterData(output_buffer_.get(), output_buffer_size_,
                                 drainable_input_buffer_.get(),
                                 drainable_input_buffer_->BytesRemaining(),
                                 &consumed_bytes, upstream_end_reached_);
   DCHECK_LE(consumed_bytes, drainable_input_buffer_->BytesRemaining());
   DCHECK(bytes_output != 0 ||
          consumed_bytes == drainable_input_buffer_->BytesRemaining());
 
   if (bytes_output == ERR_CONTENT_DECODING_FAILED) {
-    UMA_HISTOGRAM_ENUMERATION("Net.ContentDecodingFailed2.FilterType", type(),
-                              TYPE_MAX);
+    ReportContentDecodingFailed(type());
   }
   // FilterData() is not allowed to return ERR_IO_PENDING.
   DCHECK_NE(ERR_IO_PENDING, bytes_output);
 
   if (consumed_bytes > 0)
     drainable_input_buffer_->DidConsume(consumed_bytes);
 
   // Received data or encountered an error.
   if (bytes_output != 0)
     return bytes_output;
@@ skipping 16 matching lines @@
   output_buffer_size_ = 0;
 
   base::ResetAndReturn(&callback_).Run(rv);
 }
 
 bool FilterSourceStream::NeedMoreData() const {
   return !upstream_end_reached_;
 }
 
 }  // namespace net