Remove GetInputStreamBufferSize() method from FilterContext.

net/base/sdch_filter_unittest.cc

Index: net/base/sdch_filter_unittest.cc
diff --git a/net/base/sdch_filter_unittest.cc b/net/base/sdch_filter_unittest.cc
index 508365ac31c37dc599b6b117cdd638dace5af328..29d400592e59420a9060e290814da4bee49c60a9 100644
--- a/net/base/sdch_filter_unittest.cc
+++ b/net/base/sdch_filter_unittest.cc
@@ -158,9 +158,8 @@ static std::string NewSdchDictionary(const std::string& domain) {
 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));
@@ -179,9 +178,8 @@ 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");
@@ -193,7 +191,6 @@ TEST_F(SdchFilterTest, PassThroughWhenTentative) {
 
   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);
@@ -219,9 +216,8 @@ 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
@@ -236,7 +232,6 @@ TEST_F(SdchFilterTest, RefreshBadReturnCode) {
 
   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);
@@ -262,9 +257,8 @@ 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
@@ -280,7 +274,6 @@ TEST_F(SdchFilterTest, ErrorOnBadReturnCode) {
 
   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);
@@ -301,9 +294,8 @@ 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
@@ -318,7 +310,6 @@ TEST_F(SdchFilterTest, ErrorOnBadReturnCodeWithHtml) {
 
   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);
@@ -344,9 +335,8 @@ TEST_F(SdchFilterTest, ErrorOnBadReturnCodeWithHtml) {
 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));
@@ -357,7 +347,6 @@ TEST_F(SdchFilterTest, BasicBadDictionary) {
 
   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);
@@ -432,9 +421,7 @@ TEST_F(SdchFilterTest, BasicDictionary) {
   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));
@@ -472,8 +459,7 @@ TEST_F(SdchFilterTest, NoDecodeHttps) {
   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));
 
@@ -504,8 +490,7 @@ TEST_F(SdchFilterTest, NoDecodeFtp) {
   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));
 
@@ -532,8 +517,7 @@ TEST_F(SdchFilterTest, NoDecodeFileColon) {
   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));
 
@@ -560,8 +544,7 @@ TEST_F(SdchFilterTest, NoDecodeAboutColon) {
   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));
 
@@ -588,8 +571,7 @@ TEST_F(SdchFilterTest, NoDecodeJavaScript) {
   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));
 
@@ -616,8 +598,7 @@ TEST_F(SdchFilterTest, CanStillDecodeHttp) {
   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));
 
@@ -643,11 +624,10 @@ TEST_F(SdchFilterTest, CrossDomainDictionaryUse) {
 
   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)));
@@ -685,10 +665,9 @@ TEST_F(SdchFilterTest, DictionaryPathValidation) {
 
   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)));
 
@@ -739,10 +718,9 @@ TEST_F(SdchFilterTest, DictionaryPortValidation) {
 
   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)));
 
@@ -836,6 +814,13 @@ static std::string gzip_compress(const std::string &input) {
 
 //------------------------------------------------------------------------------
 
+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
@@ -860,15 +845,17 @@ TEST_F(SdchFilterTest, FilterChaining) {
   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);
@@ -886,14 +873,15 @@ TEST_F(SdchFilterTest, FilterChaining) {
   // 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;
@@ -903,8 +891,8 @@ TEST_F(SdchFilterTest, FilterChaining) {
   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;
@@ -934,8 +922,7 @@ TEST_F(SdchFilterTest, DefaultGzipIfSdch) {
   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);
@@ -994,8 +981,7 @@ TEST_F(SdchFilterTest, AcceptGzipSdchIfGzip) {
   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);
@@ -1053,8 +1039,7 @@ TEST_F(SdchFilterTest, DefaultSdchGzipIfEmpty) {
   // 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);
@@ -1116,8 +1101,7 @@ TEST_F(SdchFilterTest, AcceptGzipGzipSdchIfGzip) {
   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);