Make URLRequestHttpJob the only URLRequestJob concerned with FilterContext.

net/base/filter.cc

 // 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.
 
 #include "net/base/filter.h"
 
 #include "base/file_path.h"
 #include "base/string_util.h"
 #include "net/base/gzip_filter.h"
 #include "net/base/io_buffer.h"
@@ skipping 28 matching lines @@
 
 }  // namespace
 
 namespace net {
 
 FilterContext::~FilterContext() {
 }
 
 Filter::~Filter() {}
 
+// static
 Filter* Filter::Factory(const std::vector<FilterType>& filter_types,
                         const FilterContext& filter_context) {
   if (filter_types.empty())
     return NULL;
 
   Filter* filter_list = NULL;  // Linked list of filters.
   for (size_t i = 0; i < filter_types.size(); i++) {
     filter_list = PrependNewFilter(filter_types[i], filter_context,
                                    kFilterBufSize, filter_list);
     if (!filter_list)
       return NULL;
   }
   return filter_list;
 }
 
+// static
+Filter* Filter::GZipFactory() {
+  return InitGZipFilter(FILTER_TYPE_GZIP, kFilterBufSize);
+}
+
+// static
 Filter* Filter::FactoryForTests(const std::vector<FilterType>& filter_types,
                                 const FilterContext& filter_context,
                                 int buffer_size) {
   if (filter_types.empty())
     return NULL;
 
   Filter* filter_list = NULL;  // Linked list of filters.
   for (size_t i = 0; i < filter_types.size(); i++) {
     filter_list = PrependNewFilter(filter_types[i], filter_context,
                                    buffer_size, filter_list);
@@ skipping 259 matching lines @@
   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());
+  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));
+  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) {
-  Filter* first_filter = NULL;  // Soon to be start of chain.
+  scoped_ptr<Filter> first_filter;  // Soon to be start of chain.
   switch (type_id) {
     case FILTER_TYPE_GZIP_HELPING_SDCH:
     case FILTER_TYPE_DEFLATE:
-    case FILTER_TYPE_GZIP: {
-      scoped_ptr<net::GZipFilter> gz_filter(
-          new net::GZipFilter());
-      gz_filter->InitBuffer(buffer_size);
-      if (gz_filter->InitDecoding(type_id)) {
-        first_filter = gz_filter.release();
-      }
+    case FILTER_TYPE_GZIP:
+      first_filter.reset(InitGZipFilter(type_id, buffer_size));
       break;
-    }
     case FILTER_TYPE_SDCH:
-    case FILTER_TYPE_SDCH_POSSIBLE: {
-      scoped_ptr<net::SdchFilter> sdch_filter(
-          new net::SdchFilter(filter_context));
-      sdch_filter->InitBuffer(buffer_size);
-      if (sdch_filter->InitDecoding(type_id)) {
-        first_filter = sdch_filter.release();
-      }
+    case FILTER_TYPE_SDCH_POSSIBLE:
+      first_filter.reset(InitSdchFilter(type_id, filter_context, buffer_size));
       break;
-    }
-    default: {
+    default:
       break;
-    }
   }
 
-  if (!first_filter) {
-    // Cleanup and exit, since we can't construct this filter list.
-    delete filter_list;

[eustas, 2015/12/01 12:57:23]

Won't this cause memleaks?
Usage pattern is:
Filter* filter_list = NULL;
...
filter_list = PrependNewFilter(..., filter_list);
...

filter_list is lost and there is no way to free the memory of already created
filters.

+  if (!first_filter.get())
     return NULL;
-  }
 
   first_filter->next_filter_.reset(filter_list);
-  return first_filter;
+  return first_filter.release();
 }
 
 void Filter::InitBuffer(int buffer_size) {
   DCHECK(!stream_buffer());
   DCHECK_GT(buffer_size, 0);
   stream_buffer_ = new net::IOBuffer(buffer_size);
   stream_buffer_size_ = buffer_size;
 }
 
 void Filter::PushDataIntoNextFilter() {
   net::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