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);
 
   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_);
@@ skipping 17 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("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)));
 
   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.
@@ skipping 17 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)));
 
   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_);
@@ skipping 30 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)));
 
   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_);
 
@@ skipping 73 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 void ResetInputBuffer(Filter* filter, int size) {
+    filter->ResetInputBufferForTest(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));
 
+  const size_t kLargeInputBufferSize(1000);
+  ASSERT_LE(static_cast<int>(kLargeInputBufferSize),
+            filter->stream_buffer_size());
+  ASSERT_GT(kLargeInputBufferSize, gzip_compressed_sdch.size());
+  ASSERT_GT(kLargeInputBufferSize, sdch_compressed.size());
+  ASSERT_GT(kLargeInputBufferSize, expanded_.size());

[jar (doing other things), 2011/02/26 01:36:52]

It is OK to use asserts, but it was not clear why you changed them here.  

I'm only inclined to use an assert if code will segv if it continues (or
infinite loop, etc.).  If that is not a risk, it always seems preferable to use
an EXPECT so that we can get as much additional data in the failure scenario as
possible.

Also note that these premature returns are cases where it is probably important
to have teardown of the test class put things right (and I *think* you get that
from the test classes).

+
   // 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());
+  ASSERT_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);
+  ASSERT_LT(kMidSizedInputBufferSize * 2, sdch_compressed.size());
   filter_context.SetURL(url);
   filter.reset(Filter::Factory(filter_types, filter_context));
+  SdchFilterChainingTest::ResetInputBuffer(filter.get(),
+                                           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));
+  SdchFilterChainingTest::ResetInputBuffer(filter.get(), kLargeInputBufferSize);

[jar (doing other things), 2011/02/26 01:36:52]

You could probably put this into the teardown of your test class, so you can't
accidentally exit and fail to restore it.

 
   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