Make URLRequestHttpJob the only URLRequestJob concerned with FilterContext.

net/base/filter.h

 // Copyright (c) 2011 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.
 //
 // Filter performs filtering on data streams. Sample usage:
 //
 //   IStream* pre_filter_source;
 //   ...
 //   Filter* filter = Filter::Factory(filter_type, size);
 //   int pre_filter_data_len = filter->stream_buffer_size();
@@ skipping 120 matching lines @@
   virtual ~Filter();
 
   // Creates a Filter object.
   // Parameters: Filter_types specifies the type of filter created;
   // filter_context allows filters to acquire additional details needed for
   // construction and operation, such as a specification of requisite input
   // buffer size.
   // If success, the function returns the pointer to the Filter object created.
   // If failed or a filter is not needed, the function returns NULL.
   //
-  // Note: filter_types is an array of filter names (content encoding types as
+  // Note: filter_types is an array of filter types (content encoding types as
   // provided in an HTTP header), which will be chained together serially to do
-  // successive filtering of data.  The names in the vector are ordered based on
+  // successive filtering of data.  The types in the vector are ordered based on
   // encoding order, and the filters are chained to operate in the reverse
-  // (decoding) order. For example, types[0] = "sdch", types[1] = "gzip" will
-  // cause data to first be gunizip filtered, and the resulting output from that
-  // filter will be sdch decoded.
+  // (decoding) order. For example, types[0] = FILTER_TYPE_SDCH,
+  // types[1] = FILTER_TYPE_GZIP will cause data to first be gunzip filtered,
+  // and the resulting output from that filter will be sdch decoded.
   static Filter* Factory(const std::vector<FilterType>& filter_types,
                          const FilterContext& filter_context);
 
+  // A simpler version of Factory() which creates a single, unchained
+  // Filter of type FILTER_TYPE_GZIP, or NULL if the filter could not be
+  // initialized.
+  static Filter* GZipFactory();
+
   // External call to obtain data from this filter chain.  If ther is no
   // next_filter_, then it obtains data from this specific filter.
   FilterStatus ReadData(char* dest_buffer, int* dest_len);
 
   // Returns a pointer to the stream_buffer_.
   net::IOBuffer* stream_buffer() const { return stream_buffer_.get(); }
 
   // Returns the maximum size of stream_buffer_ in number of chars.
   int stream_buffer_size() const { return stream_buffer_size_; }
 
@@ skipping 73 matching lines @@
   // A factory helper for creating filters for within a chain of potentially
   // multiple encodings.  If a chain of filters is created, then this may be
   // called multiple times during the filter creation process.  In most simple
   // cases, this is only called once. Returns NULL and cleans up (deleting
   // filter_list) if a new filter can't be constructed.
   static Filter* PrependNewFilter(FilterType type_id,
                                   const FilterContext& filter_context,
                                   int buffer_size,
                                   Filter* filter_list);
 
+  // Helper methods for PrependNewFilter. If initialization is successful,
+  // they return a fully initialized Filter. Otherwise, return NULL.
+  static Filter* InitGZipFilter(FilterType type_id, int buffer_size);
+  static Filter* InitSdchFilter(FilterType type_id,
+                                const FilterContext& filter_context,
+                                int buffer_size);
+
   // Helper function to empty our output into the next filter's input.
   void PushDataIntoNextFilter();
 
   // Constructs a filter with an internal buffer of the given size.
   // Only meant to be called by unit tests that need to control the buffer size.
   static Filter* FactoryForTests(const std::vector<FilterType>& filter_types,
                                  const FilterContext& filter_context,
                                  int buffer_size);
 
   // An optional filter to process output from this filter.
   scoped_ptr<Filter> next_filter_;
   // Remember what status or local filter last returned so we can better handle
   // chained filters.
   FilterStatus last_status_;
 
   DISALLOW_COPY_AND_ASSIGN(Filter);
 };
 
 }  // namespace net
 
 #endif  // NET_BASE_FILTER_H__