Update from https://crrev.com/304715

net/filter/filter.cc

 // Copyright 2014 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.
 
 // The basic usage of the Filter interface is described in the comment at
 // the beginning of filter.h.  If Filter::Factory is passed a vector of
 // size greater than 1, that interface is implemented by a series of filters
 // connected in a chain.  In such a case the first filter
 // in the chain proxies calls to ReadData() so that its return values
 // apply to the entire chain.
@@ skipping 46 matching lines @@
 const int kFilterBufSize = 32 * 1024;
 
 void LogSdchProblem(const FilterContext& filter_context,
                     SdchProblemCode problem) {
   SdchManager::SdchErrorRecovery(problem);
   filter_context.GetNetLog().AddEvent(
       NetLog::TYPE_SDCH_DECODING_ERROR,
       base::Bind(&NetLogSdchResourceProblemCallback, problem));
 }
 
+std::string FilterTypeAsString(Filter::FilterType type_id) {
+  switch (type_id) {
+    case Filter::FILTER_TYPE_DEFLATE:
+      return "FILTER_TYPE_DEFLATE";
+    case Filter::FILTER_TYPE_GZIP:
+      return "FILTER_TYPE_GZIP";
+    case Filter::FILTER_TYPE_GZIP_HELPING_SDCH:
+      return "FILTER_TYPE_GZIP_HELPING_SDCH";
+    case Filter::FILTER_TYPE_SDCH:
+      return "FILTER_TYPE_SDCH";
+    case Filter::FILTER_TYPE_SDCH_POSSIBLE  :
+      return "FILTER_TYPE_SDCH_POSSIBLE  ";
+    case Filter::FILTER_TYPE_UNSUPPORTED:
+      return "FILTER_TYPE_UNSUPPORTED";
+  }
+  return "";
+}
+
 }  // namespace
 
 FilterContext::~FilterContext() {
 }
 
 Filter::~Filter() {}
 
 // static
 Filter* Filter::Factory(const std::vector<FilterType>& filter_types,
                         const FilterContext& filter_context) {
@@ skipping 256 matching lines @@
   // gunzip and tentative SDCH decoding.
   // This approach nicely handles the empty() list as well, and should work with
   // other (as yet undiscovered) proxies the choose to re-compressed with some
   // other encoding (such as bzip2, etc.).
   encoding_types->insert(encoding_types->begin(),
                          FILTER_TYPE_GZIP_HELPING_SDCH);
   encoding_types->insert(encoding_types->begin(), FILTER_TYPE_SDCH_POSSIBLE);
   return;
 }
 
-Filter::Filter()
+std::string Filter::OrderedFilterList() const {
+  if (next_filter_) {
+    return FilterTypeAsString(type_id_) + "," +
+        next_filter_->OrderedFilterList();
+  } else {
+    return FilterTypeAsString(type_id_);
+  }
+}
+
+Filter::Filter(FilterType type_id)
     : stream_buffer_(NULL),
       stream_buffer_size_(0),
       next_stream_data_(NULL),
       stream_data_len_(0),
-      last_status_(FILTER_NEED_MORE_DATA) {}
+      last_status_(FILTER_NEED_MORE_DATA),
+      type_id_(type_id) {}
 
 Filter::FilterStatus Filter::CopyOut(char* dest_buffer, int* dest_len) {
   int out_len;
   int input_len = *dest_len;
   *dest_len = 0;
 
   if (0 == stream_data_len_)
     return Filter::FILTER_NEED_MORE_DATA;
 
   out_len = std::min(input_len, stream_data_len_);
   memcpy(dest_buffer, next_stream_data_, out_len);
   *dest_len += out_len;
   stream_data_len_ -= out_len;
   if (0 == stream_data_len_) {
     next_stream_data_ = NULL;
     return Filter::FILTER_NEED_MORE_DATA;
   } else {
     next_stream_data_ += out_len;
     return Filter::FILTER_OK;
   }
 }
 
 // static
 Filter* Filter::InitGZipFilter(FilterType type_id, int buffer_size) {
-  scoped_ptr<GZipFilter> gz_filter(new GZipFilter());
+  scoped_ptr<GZipFilter> gz_filter(new GZipFilter(type_id));
   gz_filter->InitBuffer(buffer_size);
   return gz_filter->InitDecoding(type_id) ? gz_filter.release() : NULL;
 }
 
 // static
 Filter* Filter::InitSdchFilter(FilterType type_id,
                                const FilterContext& filter_context,
                                int buffer_size) {
-  scoped_ptr<SdchFilter> sdch_filter(new SdchFilter(filter_context));
+  scoped_ptr<SdchFilter> sdch_filter(new SdchFilter(type_id, filter_context));
   sdch_filter->InitBuffer(buffer_size);
   return sdch_filter->InitDecoding(type_id) ? sdch_filter.release() : NULL;
 }
 
 // static
 Filter* Filter::PrependNewFilter(FilterType type_id,
                                  const FilterContext& filter_context,
                                  int buffer_size,
                                  Filter* filter_list) {
   scoped_ptr<Filter> first_filter;  // Soon to be start of chain.
@@ skipping 31 matching lines @@
 
 void Filter::PushDataIntoNextFilter() {
   IOBuffer* next_buffer = next_filter_->stream_buffer();
   int next_size = next_filter_->stream_buffer_size();
   last_status_ = ReadFilteredData(next_buffer->data(), &next_size);
   if (FILTER_ERROR != last_status_)
     next_filter_->FlushStreamBuffer(next_size);
 }
 
 }  // namespace net