Remove GetInputStreamBufferSize() method from FilterContext.

net/base/sdch_filter_unittest.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 <limits.h>
 
 #include <algorithm>
 #include <string>
 #include <vector>
 
@@ skipping 140 matching lines @@
   dictionary.append("\n");
   dictionary.append(kTestVcdiffDictionary, sizeof(kTestVcdiffDictionary) - 1);
   return dictionary;
 }
 
 //------------------------------------------------------------------------------
 
 TEST_F(SdchFilterTest, EmptyInputOk) {
   std::vector<Filter::FilterType> filter_types;
   filter_types.push_back(Filter::FILTER_TYPE_SDCH);
-  const int kInputBufferSize(30);
   char output_buffer[20];
-  MockFilterContext filter_context(kInputBufferSize);
+  MockFilterContext filter_context;
   std::string url_string("http://ignore.com");
   filter_context.SetURL(GURL(url_string));
   scoped_ptr<Filter> filter(Filter::Factory(filter_types, filter_context));
 
 
   // With no input data, try to read output.
   int output_bytes_or_buffer_size = sizeof(output_buffer);
   Filter::FilterStatus status = filter->ReadData(output_buffer,
                                                  &output_bytes_or_buffer_size);
 
   EXPECT_EQ(0, output_bytes_or_buffer_size);
   EXPECT_EQ(Filter::FILTER_NEED_MORE_DATA, status);
 }
 
 TEST_F(SdchFilterTest, PassThroughWhenTentative) {
   std::vector<Filter::FilterType> filter_types;
   // Selective a tentative filter (which can fall back to pass through).
   filter_types.push_back(Filter::FILTER_TYPE_GZIP_HELPING_SDCH);
-  const int kInputBufferSize(30);
   char output_buffer[20];
-  MockFilterContext filter_context(kInputBufferSize);
+  MockFilterContext filter_context;
   // Response code needs to be 200 to allow a pass through.
   filter_context.SetResponseCode(200);
   std::string url_string("http://ignore.com");
   filter_context.SetURL(GURL(url_string));
   scoped_ptr<Filter> filter(Filter::Factory(filter_types, filter_context));
 
   // Supply enough data to force a pass-through mode..
   std::string non_gzip_content("not GZIPed data");
 
   char* input_buffer = filter->stream_buffer()->data();
   int input_buffer_size = filter->stream_buffer_size();
-  EXPECT_EQ(kInputBufferSize, input_buffer_size);

[jar (doing other things), 2011/03/01 22:44:03]

This test appears to (among other things) test that the requested input buffer
size is indeed obtained.  Please add that test somewhere (it works well here),
but it is critical to know that we are indeed modulating the size as needed.

[adamk, 2011/03/01 23:13:54]

This test doesn't actually seem care how big the buffer is, as far as I can
tell, only that it's big enough to hold the input data.  And so it no longer
specifies a size and uses the default buffer size.

If what you want me to test is that Filter::FactoryForTests() is appropriately
setting the buffer size, it seems to me that those tests belong with the tests
that care about the buffer size, and I've added them in the four tests (three in
GZip, one in this file).

If I'm mistaken, and it's actually important that this test be run with a
30-byte buffer, please point that out.

[jar (doing other things), 2011/03/08 02:39:01]

You're correct.  This and the next few tests don't use the buffer... but it is
always nice to use a somewhat inductive set of tests.  Initially, you test basic
items, often as simple as whether a constructor sets args (or such as buffer
being as expected), and later you test complicated interactions, and don't need
to re-test basic elements.

It is equally fine to put the checks everywhere... I just noticed the change
looking at the delta (and I personally like the inductive buliding... but it is
your choice).

On 2011/03/01 23:13:54, Adam Klein wrote:

 
   EXPECT_LT(static_cast<int>(non_gzip_content.size()),
             input_buffer_size);
   memcpy(input_buffer, non_gzip_content.data(),
          non_gzip_content.size());
   filter->FlushStreamBuffer(non_gzip_content.size());
 
   // Try to read output.
   int output_bytes_or_buffer_size = sizeof(output_buffer);
   Filter::FilterStatus status = filter->ReadData(output_buffer,
                                                  &output_bytes_or_buffer_size);
 
   EXPECT_EQ(non_gzip_content.size(),
               static_cast<size_t>(output_bytes_or_buffer_size));
   ASSERT_GT(sizeof(output_buffer),
               static_cast<size_t>(output_bytes_or_buffer_size));
   output_buffer[output_bytes_or_buffer_size] = '\0';
   EXPECT_TRUE(non_gzip_content == output_buffer);
   EXPECT_EQ(Filter::FILTER_NEED_MORE_DATA, status);
 }
 
 TEST_F(SdchFilterTest, RefreshBadReturnCode) {
   std::vector<Filter::FilterType> filter_types;
   // Selective a tentative filter (which can fall back to pass through).
   filter_types.push_back(Filter::FILTER_TYPE_SDCH_POSSIBLE);
-  const int kInputBufferSize(30);
   char output_buffer[20];
-  MockFilterContext filter_context(kInputBufferSize);
+  MockFilterContext filter_context;
   // Response code needs to be 200 to allow a pass through.
   filter_context.SetResponseCode(403);
   // Meta refresh will only appear for html content
   filter_context.SetMimeType("text/html");
   std::string url_string("http://ignore.com");
   filter_context.SetURL(GURL(url_string));
   scoped_ptr<Filter> filter(Filter::Factory(filter_types, filter_context));
 
   // Supply enough data to force a pass-through mode, which means we have
   // provided more than 9 characters that can't be a dictionary hash.
   std::string non_sdch_content("This is not SDCH");
 
   char* input_buffer = filter->stream_buffer()->data();
   int input_buffer_size = filter->stream_buffer_size();
-  EXPECT_EQ(kInputBufferSize, input_buffer_size);
 
   EXPECT_LT(static_cast<int>(non_sdch_content.size()),
             input_buffer_size);
   memcpy(input_buffer, non_sdch_content.data(),
          non_sdch_content.size());
   filter->FlushStreamBuffer(non_sdch_content.size());
 
   // Try to read output.
   int output_bytes_or_buffer_size = sizeof(output_buffer);
   Filter::FilterStatus status = filter->ReadData(output_buffer,
                                                  &output_bytes_or_buffer_size);
 
   // We should have read a long and complicated meta-refresh request.
   EXPECT_TRUE(sizeof(output_buffer) == output_bytes_or_buffer_size);
   // Check at least the prefix of the return.
   EXPECT_EQ(0, strncmp(output_buffer,
       "<head><META HTTP-EQUIV=\"Refresh\" CONTENT=\"0\"></head>",
       sizeof(output_buffer)));
   EXPECT_EQ(Filter::FILTER_OK, status);
 }
 
 TEST_F(SdchFilterTest, ErrorOnBadReturnCode) {
   std::vector<Filter::FilterType> filter_types;
   // Selective a tentative filter (which can fall back to pass through).
   filter_types.push_back(Filter::FILTER_TYPE_SDCH_POSSIBLE);
-  const int kInputBufferSize(30);
   char output_buffer[20];
-  MockFilterContext filter_context(kInputBufferSize);
+  MockFilterContext filter_context;
   // Response code needs to be 200 to allow a pass through.
   filter_context.SetResponseCode(403);
   // Meta refresh will only appear for html content, so set to something else
   // to induce an error (we can't meta refresh).
   filter_context.SetMimeType("anything");
   std::string url_string("http://ignore.com");
   filter_context.SetURL(GURL(url_string));
   scoped_ptr<Filter> filter(Filter::Factory(filter_types, filter_context));
 
   // Supply enough data to force a pass-through mode, which means we have
   // provided more than 9 characters that can't be a dictionary hash.
   std::string non_sdch_content("This is not SDCH");
 
   char* input_buffer = filter->stream_buffer()->data();
   int input_buffer_size = filter->stream_buffer_size();
-  EXPECT_EQ(kInputBufferSize, input_buffer_size);
 
   EXPECT_LT(static_cast<int>(non_sdch_content.size()),
             input_buffer_size);
   memcpy(input_buffer, non_sdch_content.data(),
          non_sdch_content.size());
   filter->FlushStreamBuffer(non_sdch_content.size());
 
   // Try to read output.
   int output_bytes_or_buffer_size = sizeof(output_buffer);
   Filter::FilterStatus status = filter->ReadData(output_buffer,
                                                  &output_bytes_or_buffer_size);
 
   EXPECT_EQ(0, output_bytes_or_buffer_size);
   EXPECT_EQ(Filter::FILTER_ERROR, status);
 }
 
 TEST_F(SdchFilterTest, ErrorOnBadReturnCodeWithHtml) {
   std::vector<Filter::FilterType> filter_types;
   // Selective a tentative filter (which can fall back to pass through).
   filter_types.push_back(Filter::FILTER_TYPE_SDCH_POSSIBLE);
-  const int kInputBufferSize(30);
   char output_buffer[20];
-  MockFilterContext filter_context(kInputBufferSize);
+  MockFilterContext filter_context;
   // Response code needs to be 200 to allow a pass through.
   filter_context.SetResponseCode(403);
   // Meta refresh will only appear for html content
   filter_context.SetMimeType("text/html");
   std::string url_string("http://ignore.com");
   filter_context.SetURL(GURL(url_string));
   scoped_ptr<Filter> filter(Filter::Factory(filter_types, filter_context));
 
   // Supply enough data to force a pass-through mode, which means we have
   // provided more than 9 characters that can't be a dictionary hash.
   std::string non_sdch_content("This is not SDCH");
 
   char* input_buffer = filter->stream_buffer()->data();
   int input_buffer_size = filter->stream_buffer_size();
-  EXPECT_EQ(kInputBufferSize, input_buffer_size);
 
   EXPECT_LT(static_cast<int>(non_sdch_content.size()),
             input_buffer_size);
   memcpy(input_buffer, non_sdch_content.data(),
          non_sdch_content.size());
   filter->FlushStreamBuffer(non_sdch_content.size());
 
   // Try to read output.
   int output_bytes_or_buffer_size = sizeof(output_buffer);
   Filter::FilterStatus status = filter->ReadData(output_buffer,
                                                  &output_bytes_or_buffer_size);
 
   // We should have read a long and complicated meta-refresh request.
   EXPECT_EQ(sizeof(output_buffer),
             static_cast<size_t>(output_bytes_or_buffer_size));
   // Check at least the prefix of the return.
   EXPECT_EQ(0, strncmp(output_buffer,
       "<head><META HTTP-EQUIV=\"Refresh\" CONTENT=\"0\"></head>",
       sizeof(output_buffer)));
   EXPECT_EQ(Filter::FILTER_OK, status);
 }
 
 TEST_F(SdchFilterTest, BasicBadDictionary) {
   std::vector<Filter::FilterType> filter_types;
   filter_types.push_back(Filter::FILTER_TYPE_SDCH);
-  const int kInputBufferSize(30);
   char output_buffer[20];
-  MockFilterContext filter_context(kInputBufferSize);
+  MockFilterContext filter_context;
   std::string url_string("http://ignore.com");
   filter_context.SetURL(GURL(url_string));
   scoped_ptr<Filter> filter(Filter::Factory(filter_types, filter_context));
 
   // Supply bogus data (which doesn't yet specify a full dictionary hash).
   // Dictionary hash is 8 characters followed by a null.
   std::string dictionary_hash_prefix("123");
 
   char* input_buffer = filter->stream_buffer()->data();
   int input_buffer_size = filter->stream_buffer_size();
-  EXPECT_EQ(kInputBufferSize, input_buffer_size);
 
   EXPECT_LT(static_cast<int>(dictionary_hash_prefix.size()),
             input_buffer_size);
   memcpy(input_buffer, dictionary_hash_prefix.data(),
          dictionary_hash_prefix.size());
   filter->FlushStreamBuffer(dictionary_hash_prefix.size());
 
   // With less than a dictionary specifier, try to read output.
   int output_bytes_or_buffer_size = sizeof(output_buffer);
   Filter::FilterStatus status = filter->ReadData(output_buffer,
@@ skipping 54 matching lines @@
   std::string url_string = "http://" + kSampleDomain;
 
   GURL url(url_string);
   EXPECT_TRUE(sdch_manager_->AddSdchDictionary(dictionary, url));
 
   std::string compressed(NewSdchCompressedData(dictionary));
 
   std::vector<Filter::FilterType> filter_types;
   filter_types.push_back(Filter::FILTER_TYPE_SDCH);
 
-  // Decode with a large buffer (larger than test input, or compressed data).
-  const int kInputBufferSize(100);
-  MockFilterContext filter_context(kInputBufferSize);
+  MockFilterContext filter_context;
   filter_context.SetURL(url);
 
   scoped_ptr<Filter> filter(Filter::Factory(filter_types, filter_context));
 
   size_t feed_block_size = 100;
   size_t output_block_size = 100;
   std::string output;
   EXPECT_TRUE(FilterTestData(compressed, feed_block_size, output_block_size,
                              filter.get(), &output));
   EXPECT_EQ(output, expanded_);
 
   // Decode with really small buffers (size 1) to check for edge effects.
-  filter.reset((Filter::Factory(filter_types, filter_context)));
+  filter.reset(Filter::Factory(filter_types, filter_context));
 
   feed_block_size = 1;
   output_block_size = 1;
   output.clear();
   EXPECT_TRUE(FilterTestData(compressed, feed_block_size, output_block_size,
                              filter.get(), &output));
   EXPECT_EQ(output, expanded_);
 }
 
 TEST_F(SdchFilterTest, NoDecodeHttps) {
   // Construct a valid SDCH dictionary from a VCDIFF dictionary.
   const std::string kSampleDomain = "sdchtest.com";
   std::string dictionary(NewSdchDictionary(kSampleDomain));
 
   std::string url_string = "http://" + kSampleDomain;
 
   GURL url(url_string);
   EXPECT_TRUE(sdch_manager_->AddSdchDictionary(dictionary, url));
 
   std::string compressed(NewSdchCompressedData(dictionary));
 
   std::vector<Filter::FilterType> filter_types;
   filter_types.push_back(Filter::FILTER_TYPE_SDCH);
 
-  const int kInputBufferSize(100);
-  MockFilterContext filter_context(kInputBufferSize);
+  MockFilterContext filter_context;
   filter_context.SetURL(GURL("https://" + kSampleDomain));
   scoped_ptr<Filter> filter(Filter::Factory(filter_types, filter_context));
 
   const size_t feed_block_size(100);
   const size_t output_block_size(100);
   std::string output;
 
   EXPECT_FALSE(FilterTestData(compressed, feed_block_size, output_block_size,
                              filter.get(), &output));
 }
@@ skipping 10 matching lines @@
   std::string url_string = "http://" + kSampleDomain;
 
   GURL url(url_string);
   EXPECT_TRUE(sdch_manager_->AddSdchDictionary(dictionary, url));
 
   std::string compressed(NewSdchCompressedData(dictionary));
 
   std::vector<Filter::FilterType> filter_types;
   filter_types.push_back(Filter::FILTER_TYPE_SDCH);
 
-  const int kInputBufferSize(100);
-  MockFilterContext filter_context(kInputBufferSize);
+  MockFilterContext filter_context;
   filter_context.SetURL(GURL("ftp://" + kSampleDomain));
   scoped_ptr<Filter> filter(Filter::Factory(filter_types, filter_context));
 
   const size_t feed_block_size(100);
   const size_t output_block_size(100);
   std::string output;
 
   EXPECT_FALSE(FilterTestData(compressed, feed_block_size, output_block_size,
                              filter.get(), &output));
 }
 
 TEST_F(SdchFilterTest, NoDecodeFileColon) {
   // Construct a valid SDCH dictionary from a VCDIFF dictionary.
   const std::string kSampleDomain = "sdchtest.com";
   std::string dictionary(NewSdchDictionary(kSampleDomain));
 
   std::string url_string = "http://" + kSampleDomain;
 
   GURL url(url_string);
   EXPECT_TRUE(sdch_manager_->AddSdchDictionary(dictionary, url));
 
   std::string compressed(NewSdchCompressedData(dictionary));
 
   std::vector<Filter::FilterType> filter_types;
   filter_types.push_back(Filter::FILTER_TYPE_SDCH);
 
-  const int kInputBufferSize(100);
-  MockFilterContext filter_context(kInputBufferSize);
+  MockFilterContext filter_context;
   filter_context.SetURL(GURL("file://" + kSampleDomain));
   scoped_ptr<Filter> filter(Filter::Factory(filter_types, filter_context));
 
   const size_t feed_block_size(100);
   const size_t output_block_size(100);
   std::string output;
 
   EXPECT_FALSE(FilterTestData(compressed, feed_block_size, output_block_size,
                              filter.get(), &output));
 }
 
 TEST_F(SdchFilterTest, NoDecodeAboutColon) {
   // Construct a valid SDCH dictionary from a VCDIFF dictionary.
   const std::string kSampleDomain = "sdchtest.com";
   std::string dictionary(NewSdchDictionary(kSampleDomain));
 
   std::string url_string = "http://" + kSampleDomain;
 
   GURL url(url_string);
   EXPECT_TRUE(sdch_manager_->AddSdchDictionary(dictionary, url));
 
   std::string compressed(NewSdchCompressedData(dictionary));
 
   std::vector<Filter::FilterType> filter_types;
   filter_types.push_back(Filter::FILTER_TYPE_SDCH);
 
-  const int kInputBufferSize(100);
-  MockFilterContext filter_context(kInputBufferSize);
+  MockFilterContext filter_context;
   filter_context.SetURL(GURL("about://" + kSampleDomain));
   scoped_ptr<Filter> filter(Filter::Factory(filter_types, filter_context));
 
   const size_t feed_block_size(100);
   const size_t output_block_size(100);
   std::string output;
 
   EXPECT_FALSE(FilterTestData(compressed, feed_block_size, output_block_size,
                              filter.get(), &output));
 }
 
 TEST_F(SdchFilterTest, NoDecodeJavaScript) {
   // Construct a valid SDCH dictionary from a VCDIFF dictionary.
   const std::string kSampleDomain = "sdchtest.com";
   std::string dictionary(NewSdchDictionary(kSampleDomain));
 
   std::string url_string = "http://" + kSampleDomain;
 
   GURL url(url_string);
   EXPECT_TRUE(sdch_manager_->AddSdchDictionary(dictionary, url));
 
   std::string compressed(NewSdchCompressedData(dictionary));
 
   std::vector<Filter::FilterType> filter_types;
   filter_types.push_back(Filter::FILTER_TYPE_SDCH);
 
-  const int kInputBufferSize(100);
-  MockFilterContext filter_context(kInputBufferSize);
+  MockFilterContext filter_context;
   filter_context.SetURL(GURL("javascript://" + kSampleDomain));
   scoped_ptr<Filter> filter(Filter::Factory(filter_types, filter_context));
 
   const size_t feed_block_size(100);
   const size_t output_block_size(100);
   std::string output;
 
   EXPECT_FALSE(FilterTestData(compressed, feed_block_size, output_block_size,
                              filter.get(), &output));
 }
 
 TEST_F(SdchFilterTest, CanStillDecodeHttp) {
   // Construct a valid SDCH dictionary from a VCDIFF dictionary.
   const std::string kSampleDomain = "sdchtest.com";
   std::string dictionary(NewSdchDictionary(kSampleDomain));
 
   std::string url_string = "http://" + kSampleDomain;
 
   GURL url(url_string);
   EXPECT_TRUE(sdch_manager_->AddSdchDictionary(dictionary, url));
 
   std::string compressed(NewSdchCompressedData(dictionary));
 
   std::vector<Filter::FilterType> filter_types;
   filter_types.push_back(Filter::FILTER_TYPE_SDCH);
 
-  const int kInputBufferSize(100);
-  MockFilterContext filter_context(kInputBufferSize);
+  MockFilterContext filter_context;
   filter_context.SetURL(GURL("http://" + kSampleDomain));
   scoped_ptr<Filter> filter(Filter::Factory(filter_types, filter_context));
 
   const size_t feed_block_size(100);
   const size_t output_block_size(100);
   std::string output;
 
   EXPECT_TRUE(FilterTestData(compressed, feed_block_size, output_block_size,
                              filter.get(), &output));
 }
 
 TEST_F(SdchFilterTest, CrossDomainDictionaryUse) {
   // Construct a valid SDCH dictionary from a VCDIFF dictionary.
   const std::string kSampleDomain = "sdchtest.com";
   std::string dictionary(NewSdchDictionary(kSampleDomain));
 
   std::string url_string = "http://" + kSampleDomain;
 
   GURL url(url_string);
   EXPECT_TRUE(sdch_manager_->AddSdchDictionary(dictionary, url));
 
   std::string compressed(NewSdchCompressedData(dictionary));
 
   std::vector<Filter::FilterType> filter_types;
   filter_types.push_back(Filter::FILTER_TYPE_SDCH);
-  const int kInputBufferSize(100);
 
   // Decode with content arriving from the "wrong" domain.
   // This tests SdchManager::CanSet().
-  MockFilterContext filter_context(kInputBufferSize);
+  MockFilterContext filter_context;
   GURL wrong_domain_url("http://www.wrongdomain.com");
   filter_context.SetURL(wrong_domain_url);
-  scoped_ptr<Filter> filter((Filter::Factory(filter_types,  filter_context)));
+  scoped_ptr<Filter> filter(Filter::Factory(filter_types,  filter_context));
 
   size_t feed_block_size = 100;
   size_t output_block_size = 100;
   std::string output;
   EXPECT_FALSE(FilterTestData(compressed, feed_block_size, output_block_size,
                               filter.get(), &output));
   EXPECT_EQ(output.size(), 0u);  // No output written.
 
   EXPECT_TRUE(SdchManager::Global()->IsInSupportedDomain(GURL(url_string)));
   EXPECT_FALSE(SdchManager::Global()->IsInSupportedDomain(wrong_domain_url));
@@ skipping 14 matching lines @@
   // Create a dictionary with a path restriction, by prefixing dictionary.
   const std::string path("/special_path/bin");
   std::string dictionary_with_path("Path: " + path + "\n");
   dictionary_with_path.append(dictionary);
   EXPECT_TRUE(sdch_manager_->AddSdchDictionary(dictionary_with_path, url));
 
   std::string compressed_for_path(NewSdchCompressedData(dictionary_with_path));
 
   std::vector<Filter::FilterType> filter_types;
   filter_types.push_back(Filter::FILTER_TYPE_SDCH);
-  const int kInputBufferSize(100);
 
   // Test decode the path data, arriving from a valid path.
-  MockFilterContext filter_context(kInputBufferSize);
+  MockFilterContext filter_context;
   filter_context.SetURL(GURL(url_string + path));
-  scoped_ptr<Filter> filter((Filter::Factory(filter_types, filter_context)));
+  scoped_ptr<Filter> filter(Filter::Factory(filter_types, filter_context));
 
   size_t feed_block_size = 100;
   size_t output_block_size = 100;
   std::string output;
 
   EXPECT_TRUE(FilterTestData(compressed_for_path, feed_block_size,
                              output_block_size, filter.get(), &output));
   EXPECT_EQ(output, expanded_);
 
   // Test decode the path data, arriving from a invalid path.
   filter_context.SetURL(GURL(url_string));
-  filter.reset((Filter::Factory(filter_types, filter_context)));
+  filter.reset(Filter::Factory(filter_types, filter_context));
 
   feed_block_size = 100;
   output_block_size = 100;
   output.clear();
   EXPECT_FALSE(FilterTestData(compressed_for_path, feed_block_size,
                               output_block_size, filter.get(), &output));
   EXPECT_EQ(output.size(), 0u);  // No output written.
 
   EXPECT_FALSE(SdchManager::Global()->IsInSupportedDomain(GURL(url_string)));
   SdchManager::ClearBlacklistings();
@@ skipping 16 matching lines @@
   std::string dictionary_with_port("Port: " + port + "\n");
   dictionary_with_port.append("Port: 80\n");  // Add default port.
   dictionary_with_port.append(dictionary);
   EXPECT_TRUE(sdch_manager_->AddSdchDictionary(dictionary_with_port,
                                             GURL(url_string + ":" + port)));
 
   std::string compressed_for_port(NewSdchCompressedData(dictionary_with_port));
 
   std::vector<Filter::FilterType> filter_types;
   filter_types.push_back(Filter::FILTER_TYPE_SDCH);
-  const int kInputBufferSize(100);
 
   // Test decode the port data, arriving from a valid port.
-  MockFilterContext filter_context(kInputBufferSize);
+  MockFilterContext filter_context;
   filter_context.SetURL(GURL(url_string + ":" + port));
-  scoped_ptr<Filter> filter((Filter::Factory(filter_types, filter_context)));
+  scoped_ptr<Filter> filter(Filter::Factory(filter_types, filter_context));
 
   size_t feed_block_size = 100;
   size_t output_block_size = 100;
   std::string output;
   EXPECT_TRUE(FilterTestData(compressed_for_port, feed_block_size,
                              output_block_size, filter.get(), &output));
   EXPECT_EQ(output, expanded_);
 
   // Test decode the port data, arriving from a valid (default) port.
   filter_context.SetURL(GURL(url_string));  // Default port.
-  filter.reset((Filter::Factory(filter_types, filter_context)));
+  filter.reset(Filter::Factory(filter_types, filter_context));
 
   feed_block_size = 100;
   output_block_size = 100;
   output.clear();
   EXPECT_TRUE(FilterTestData(compressed_for_port, feed_block_size,
                              output_block_size, filter.get(), &output));
   EXPECT_EQ(output, expanded_);
 
   // Test decode the port data, arriving from a invalid port.
   filter_context.SetURL(GURL(url_string + ":" + port + "1"));
-  filter.reset((Filter::Factory(filter_types, filter_context)));
+  filter.reset(Filter::Factory(filter_types, filter_context));
 
   feed_block_size = 100;
   output_block_size = 100;
   output.clear();
   EXPECT_FALSE(FilterTestData(compressed_for_port, feed_block_size,
                               output_block_size, filter.get(), &output));
   EXPECT_EQ(output.size(), 0u);  // No output written.
 
   EXPECT_FALSE(SdchManager::Global()->IsInSupportedDomain(GURL(url_string)));
   SdchManager::ClearBlacklistings();
@@ skipping 49 matching lines @@
   // Do deflate
   code = deflate(&zlib_stream, Z_FINISH);
   gzip_compressed_length -= zlib_stream.avail_out;
   std::string compressed(gzip_compressed.get(), gzip_compressed_length);
   deflateEnd(&zlib_stream);
   return compressed;
 }
 
 //------------------------------------------------------------------------------
 
+class SdchFilterChainingTest {
+ public:
+  static Filter* Factory(const std::vector<Filter::FilterType>& types,
+                           const FilterContext& context, int size) {
+    return Filter::FactoryForTests(types, context, size);
+  }
+};
+
 // Test that filters can be cascaded (chained) so that the output of one filter
 // is processed by the next one.  This is most critical for SDCH, which is
 // routinely followed by gzip (during encoding).  The filter we'll test for will
 // do the gzip decoding first, and then decode the SDCH content.
 TEST_F(SdchFilterTest, FilterChaining) {
   // Construct a valid SDCH dictionary from a VCDIFF dictionary.
   const std::string kSampleDomain = "sdchtest.com";
   std::string dictionary(NewSdchDictionary(kSampleDomain));
 
   std::string url_string = "http://" + kSampleDomain;
 
   GURL url(url_string);
   EXPECT_TRUE(sdch_manager_->AddSdchDictionary(dictionary, url));
 
   std::string sdch_compressed(NewSdchCompressedData(dictionary));
 
   // Use Gzip to compress the sdch sdch_compressed data.
   std::string gzip_compressed_sdch = gzip_compress(sdch_compressed);
 
   // Construct a chained filter.
   std::vector<Filter::FilterType> filter_types;
   filter_types.push_back(Filter::FILTER_TYPE_SDCH);
   filter_types.push_back(Filter::FILTER_TYPE_GZIP);
 
   // First try with a large buffer (larger than test input, or compressed data).
   const size_t kLargeInputBufferSize(1000);  // Used internally in filters.
   CHECK_GT(kLargeInputBufferSize, gzip_compressed_sdch.size());
   CHECK_GT(kLargeInputBufferSize, sdch_compressed.size());
   CHECK_GT(kLargeInputBufferSize, expanded_.size());
-  MockFilterContext filter_context(kLargeInputBufferSize);
+  MockFilterContext filter_context;
   filter_context.SetURL(url);
-  scoped_ptr<Filter> filter(Filter::Factory(filter_types, filter_context));
+  scoped_ptr<Filter> filter(
+      SdchFilterChainingTest::Factory(filter_types, filter_context,
+                                      kLargeInputBufferSize));
 
   // Verify that chained filter is waiting for data.
   char tiny_output_buffer[10];
   int tiny_output_size = sizeof(tiny_output_buffer);
   EXPECT_EQ(Filter::FILTER_NEED_MORE_DATA,
             filter->ReadData(tiny_output_buffer, &tiny_output_size));
 
   // Make chain process all data.
   size_t feed_block_size = kLargeInputBufferSize;
   size_t output_block_size = kLargeInputBufferSize;
   std::string output;
   EXPECT_TRUE(FilterTestData(gzip_compressed_sdch, feed_block_size,
                              output_block_size, filter.get(), &output));
   EXPECT_EQ(output, expanded_);
 
   // Next try with a mid-sized internal buffer size.
   const size_t kMidSizedInputBufferSize(100);
   // Buffer should be big enough to swallow whole gzip content.
   CHECK_GT(kMidSizedInputBufferSize, gzip_compressed_sdch.size());
   // Buffer should be small enough that entire SDCH content can't fit.
   // We'll go even further, and force the chain to flush the buffer between the
   // two filters more than once (that is why we multiply by 2).
   CHECK_LT(kMidSizedInputBufferSize * 2, sdch_compressed.size());
-  filter_context.SetBufferSize(kMidSizedInputBufferSize);
   filter_context.SetURL(url);
-  filter.reset(Filter::Factory(filter_types, filter_context));
+  filter.reset(
+      SdchFilterChainingTest::Factory(filter_types, filter_context,
+                                      kMidSizedInputBufferSize));
 
   feed_block_size = kMidSizedInputBufferSize;
   output_block_size = kMidSizedInputBufferSize;
   output.clear();
   EXPECT_TRUE(FilterTestData(gzip_compressed_sdch, feed_block_size,
                              output_block_size, filter.get(), &output));
   EXPECT_EQ(output, expanded_);
 
   // Next try with a tiny input and output buffer to cover edge effects.
-  filter_context.SetBufferSize(kLargeInputBufferSize);
-  filter.reset(Filter::Factory(filter_types, filter_context));
+  filter.reset(SdchFilterChainingTest::Factory(filter_types, filter_context,
+                                               kLargeInputBufferSize));
 
   feed_block_size = 1;
   output_block_size = 1;
   output.clear();
   EXPECT_TRUE(FilterTestData(gzip_compressed_sdch, feed_block_size,
                              output_block_size, filter.get(), &output));
   EXPECT_EQ(output, expanded_);
 }
 
 TEST_F(SdchFilterTest, DefaultGzipIfSdch) {
   // Construct a valid SDCH dictionary from a VCDIFF dictionary.
   const std::string kSampleDomain = "sdchtest.com";
   std::string dictionary(NewSdchDictionary(kSampleDomain));
 
   std::string url_string = "http://" + kSampleDomain;
 
   GURL url(url_string);
   EXPECT_TRUE(sdch_manager_->AddSdchDictionary(dictionary, url));
 
   std::string sdch_compressed(NewSdchCompressedData(dictionary));
 
   // Use Gzip to compress the sdch sdch_compressed data.
   std::string gzip_compressed_sdch = gzip_compress(sdch_compressed);
 
   // Only claim to have sdch content, but really use the gzipped sdch content.
   // System should automatically add the missing (optional) gzip.
   std::vector<Filter::FilterType> filter_types;
   filter_types.push_back(Filter::FILTER_TYPE_SDCH);
 
-  const int kInputBufferSize(100);
-  MockFilterContext filter_context(kInputBufferSize);
+  MockFilterContext filter_context;
   filter_context.SetMimeType("anything/mime");
   filter_context.SetSdchResponse(true);
   Filter::FixupEncodingTypes(filter_context, &filter_types);
   ASSERT_EQ(filter_types.size(), 2u);
   EXPECT_EQ(filter_types[0], Filter::FILTER_TYPE_SDCH);
   EXPECT_EQ(filter_types[1], Filter::FILTER_TYPE_GZIP_HELPING_SDCH);
 
   // First try with a large buffer (larger than test input, or compressed data).
   filter_context.SetURL(url);
   scoped_ptr<Filter> filter(Filter::Factory(filter_types, filter_context));
@@ skipping 38 matching lines @@
   // Use Gzip to compress the sdch sdch_compressed data.
   std::string gzip_compressed_sdch = gzip_compress(sdch_compressed);
 
   // Some proxies strip the content encoding statement down to a mere gzip, but
   // pass through the original content (with full sdch,gzip encoding).
   // Only claim to have gzip content, but really use the gzipped sdch content.
   // System should automatically add the missing (optional) sdch.
   std::vector<Filter::FilterType> filter_types;
   filter_types.push_back(Filter::FILTER_TYPE_GZIP);
 
-  const int kInputBufferSize(100);
-  MockFilterContext filter_context(kInputBufferSize);
+  MockFilterContext filter_context;
   filter_context.SetMimeType("anything/mime");
   filter_context.SetSdchResponse(true);
   Filter::FixupEncodingTypes(filter_context, &filter_types);
   ASSERT_EQ(filter_types.size(), 3u);
   EXPECT_EQ(filter_types[0], Filter::FILTER_TYPE_SDCH_POSSIBLE);
   EXPECT_EQ(filter_types[1], Filter::FILTER_TYPE_GZIP_HELPING_SDCH);
   EXPECT_EQ(filter_types[2], Filter::FILTER_TYPE_GZIP);
 
   // First try with a large buffer (larger than test input, or compressed data).
   filter_context.SetURL(url);
@@ skipping 37 matching lines @@
   std::string sdch_compressed(NewSdchCompressedData(dictionary));
 
   // Use Gzip to compress the sdch sdch_compressed data.
   std::string gzip_compressed_sdch = gzip_compress(sdch_compressed);
 
   // Only claim to have non-encoded content, but really use the gzipped sdch
   // content.
   // System should automatically add the missing (optional) sdch,gzip.
   std::vector<Filter::FilterType> filter_types;
 
-  const int kInputBufferSize(100);
-  MockFilterContext filter_context(kInputBufferSize);
+  MockFilterContext filter_context;
   filter_context.SetMimeType("anything/mime");
   filter_context.SetSdchResponse(true);
   Filter::FixupEncodingTypes(filter_context, &filter_types);
   ASSERT_EQ(filter_types.size(), 2u);
   EXPECT_EQ(filter_types[0], Filter::FILTER_TYPE_SDCH_POSSIBLE);
   EXPECT_EQ(filter_types[1], Filter::FILTER_TYPE_GZIP_HELPING_SDCH);
 
   // First try with a large buffer (larger than test input, or compressed data).
   filter_context.SetURL(url);
   scoped_ptr<Filter> filter(Filter::Factory(filter_types, filter_context));
@@ skipping 41 matching lines @@
   // Use Gzip to double compress the sdch sdch_compressed data.
   std::string double_gzip_compressed_sdch = gzip_compress(gzip_compress(
       sdch_compressed));
 
   // Only claim to have gzip content, but really use the double gzipped sdch
   // content.
   // System should automatically add the missing (optional) sdch, gzip decoders.
   std::vector<Filter::FilterType> filter_types;
   filter_types.push_back(Filter::FILTER_TYPE_GZIP);
 
-  const int kInputBufferSize(100);
-  MockFilterContext filter_context(kInputBufferSize);
+  MockFilterContext filter_context;
   filter_context.SetMimeType("anything/mime");
   filter_context.SetSdchResponse(true);
   Filter::FixupEncodingTypes(filter_context, &filter_types);
   ASSERT_EQ(filter_types.size(), 3u);
   EXPECT_EQ(filter_types[0], Filter::FILTER_TYPE_SDCH_POSSIBLE);
   EXPECT_EQ(filter_types[1], Filter::FILTER_TYPE_GZIP_HELPING_SDCH);
   EXPECT_EQ(filter_types[2], Filter::FILTER_TYPE_GZIP);
 
   // First try with a large buffer (larger than test input, or compressed data).
   filter_context.SetURL(url);
@@ skipping 270 matching lines @@
   sdch_manager_->SetAllowLatencyExperiment(url, false);
   EXPECT_FALSE(sdch_manager_->AllowLatencyExperiment(url));
   EXPECT_TRUE(sdch_manager_->AllowLatencyExperiment(url2));
 
   sdch_manager_->SetAllowLatencyExperiment(url2, false);
   EXPECT_FALSE(sdch_manager_->AllowLatencyExperiment(url));
   EXPECT_FALSE(sdch_manager_->AllowLatencyExperiment(url2));
 }
 
 }  // namespace net