Remove GetInputStreamBufferSize() method from 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 16 matching lines @@
 const char kUncompressed[] = "uncompressed";
 
 // Mime types:
 const char kApplicationXGzip[]     = "application/x-gzip";
 const char kApplicationGzip[]      = "application/gzip";
 const char kApplicationXGunzip[]   = "application/x-gunzip";
 const char kApplicationXCompress[] = "application/x-compress";
 const char kApplicationCompress[]  = "application/compress";
 const char kTextHtml[]             = "text/html";
 
+// Buffer size allocated when de-compressing data.
+const int kFilterBufSize = 32 * 1024;
+
 }  // namespace
 
 FilterContext::~FilterContext() {
 }
 
 Filter::~Filter() {}
 
 Filter* Filter::Factory(const std::vector<FilterType>& filter_types,
                         const FilterContext& filter_context) {
-  DCHECK_GT(filter_context.GetInputStreamBufferSize(), 0);
-  if (filter_types.empty() || filter_context.GetInputStreamBufferSize() <= 0)
+  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,
-                                   filter_list);
+                                   kFilterBufSize, filter_list);
     if (!filter_list)
       return NULL;
   }
+  return filter_list;
+}
+
+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);
+    if (!filter_list)
+      return NULL;
+  }
   return filter_list;
 }
 
 Filter::FilterStatus Filter::ReadData(char* dest_buffer, int* dest_len) {
   const int dest_buffer_capacity = *dest_len;
   if (last_status_ == FILTER_ERROR)
     return last_status_;
   if (!next_filter_.get())
     return last_status_ = ReadFilteredData(dest_buffer, dest_len);
   if (last_status_ == FILTER_NEED_MORE_DATA && !stream_data_len())
@@ skipping 254 matching lines @@
     return Filter::FILTER_NEED_MORE_DATA;
   } else {
     next_stream_data_ += out_len;
     return Filter::FILTER_OK;
   }
 }
 
 // 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.
   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(filter_context));
-      if (gz_filter->InitBuffer()) {
-        if (gz_filter->InitDecoding(type_id)) {
-          first_filter = gz_filter.release();
-        }
+      gz_filter->InitBuffer(buffer_size);
+      if (gz_filter->InitDecoding(type_id)) {
+        first_filter = gz_filter.release();
       }
       break;
     }
     case FILTER_TYPE_SDCH:
     case FILTER_TYPE_SDCH_POSSIBLE: {
       scoped_ptr<net::SdchFilter> sdch_filter(
           new net::SdchFilter(filter_context));
-      if (sdch_filter->InitBuffer()) {
-        if (sdch_filter->InitDecoding(type_id)) {
-          first_filter = sdch_filter.release();
-        }
+      sdch_filter->InitBuffer(buffer_size);
+      if (sdch_filter->InitDecoding(type_id)) {
+        first_filter = sdch_filter.release();
       }
       break;
     }
     default: {
       break;
     }
   }
 
   if (!first_filter) {
     // Cleanup and exit, since we can't construct this filter list.
     delete filter_list;
     return NULL;
   }
 
   first_filter->next_filter_.reset(filter_list);
   return first_filter;
 }
 
-bool Filter::InitBuffer() {
-  int buffer_size = filter_context_.GetInputStreamBufferSize();
+void Filter::InitBuffer(int buffer_size) {
+  DCHECK(!stream_buffer());
   DCHECK_GT(buffer_size, 0);
-  if (buffer_size <= 0 || stream_buffer())
-    return false;
-
   stream_buffer_ = new net::IOBuffer(buffer_size);
-
-  if (stream_buffer()) {
-    stream_buffer_size_ = buffer_size;
-    return true;
-  }
-
-  return false;
+  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);
 }