Remove GetInputStreamBufferSize() method from FilterContext.

net/base/gzip_filter_unittest.cc

 // Copyright (c) 2006-2008 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 <fstream>
 #include <iostream>
 
 #if defined(USE_SYSTEM_ZLIB)
 #include <zlib.h>
 #else
 #include "third_party/zlib/zlib.h"
 #endif
 
 #include "base/file_util.h"
 #include "base/path_service.h"
 #include "base/scoped_ptr.h"
 #include "net/base/gzip_filter.h"
 #include "net/base/mock_filter_context.h"
 #include "net/base/io_buffer.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "testing/platform_test.h"
 
 namespace {
 
 const int kDefaultBufferSize = 4096;
 const int kSmallBufferSize = 128;
-const int kMaxBufferSize = 1048576;    // 1048576 == 2^20 == 1 MB
 
 const char kApplicationOctetStream[] = "application/octet-stream";
 const char kApplicationXGzip[] = "application/x-gzip";
 const char kApplicationGzip[] = "application/gzip";
 const char kApplicationXGunzip[] = "application/x-gunzip";
 
 // The GZIP header (see RFC 1952):
 //   +---+---+---+---+---+---+---+---+---+---+
 //   |ID1|ID2|CM |FLG|     MTIME     |XFL|OS |
 //   +---+---+---+---+---+---+---+---+---+---+
 //     ID1     \037
 //     ID2     \213
 //     CM      \010 (compression method == DEFLATE)
 //     FLG     \000 (special flags that we do not support)
 //     MTIME   Unix format modification time (0 means not available)
 //     XFL     2-4? DEFLATE flags
 //     OS      ???? Operating system indicator (255 means unknown)
 //
 // Header value we generate:
 const char kGZipHeader[] = { '\037', '\213', '\010', '\000', '\000',
                              '\000', '\000', '\000', '\002', '\377' };
 
 enum EncodeMode {
   ENCODE_GZIP,      // Wrap the deflate with a GZip header.
   ENCODE_DEFLATE    // Raw deflate.
 };
 
+}  // namespace
+
 // These tests use the path service, which uses autoreleased objects on the
 // Mac, so this needs to be a PlatformTest.
 class GZipUnitTest : public PlatformTest {
  protected:
   virtual void SetUp() {
     PlatformTest::SetUp();
 
     deflate_encode_buffer_ = NULL;
     gzip_encode_buffer_ = NULL;
 
@@ skipping 148 matching lines @@
   // Dest is the buffer for decoding results. Upon entry, *dest_len is the size
   // of the dest buffer. Upon exit, *dest_len is the number of chars written
   // into the buffer.
   int DecodeAllWithFilter(Filter* filter, const char* source, int source_len,
                           char* dest, int* dest_len) {
     memcpy(filter->stream_buffer()->data(), source, source_len);
     filter->FlushStreamBuffer(source_len);
     return filter->ReadData(dest, dest_len);
   }
 
+  void InitFilter(Filter::FilterType type) {
+    std::vector<Filter::FilterType> filter_types;
+    filter_types.push_back(type);
+    filter_.reset(Filter::Factory(filter_types, filter_context_));
+    ASSERT_TRUE(filter_.get());
+  }
+
+  void InitFilterWithBufferSize(Filter::FilterType type, int buffer_size) {
+    std::vector<Filter::FilterType> filter_types;
+    filter_types.push_back(type);
+    filter_.reset(Filter::FactoryForTests(filter_types, filter_context_,
+                                          buffer_size));
+    ASSERT_TRUE(filter_.get());
+  }
+
   const char* source_buffer() const { return source_buffer_.data(); }
   int source_len() const { return static_cast<int>(source_buffer_.size()); }
 
+  scoped_ptr<Filter> filter_;
+
   std::string source_buffer_;
 
   char* deflate_encode_buffer_;
   int deflate_encode_len_;
 
   char* gzip_encode_buffer_;
   int gzip_encode_len_;
+
+ private:
+  net::MockFilterContext filter_context_;
 };
 
 // Basic scenario: decoding deflate data with big enough buffer.
 TEST_F(GZipUnitTest, DecodeDeflate) {
   // Decode the compressed data with filter
-  std::vector<Filter::FilterType> filter_types;
-  filter_types.push_back(Filter::FILTER_TYPE_DEFLATE);
-  net::MockFilterContext filter_context(kDefaultBufferSize);
-  scoped_ptr<Filter> filter(Filter::Factory(filter_types, filter_context));
-  ASSERT_TRUE(filter.get());
-  memcpy(filter->stream_buffer()->data(), deflate_encode_buffer_,
+  InitFilter(Filter::FILTER_TYPE_DEFLATE);
+  memcpy(filter_->stream_buffer()->data(), deflate_encode_buffer_,
          deflate_encode_len_);

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

With this code not being explicit about buffer size, the above code (which I
didn't write) shows off the use of memcpy() without an assert or checking.  

Could you add one:
ASSERT_GT(filter_->stream_buffer().size() > deflate_encode_len_);

IMO, the same assert should preface any memcpy() calls like this below.

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

I've added this assert to InitBuffer().  There are already ASSERTs in SetUp()
that these member buffers are <= kDefaultBufferSize; same goes for those tests
that call DecodeAllWithFilter().

-  filter->FlushStreamBuffer(deflate_encode_len_);
+  filter_->FlushStreamBuffer(deflate_encode_len_);
 
   char deflate_decode_buffer[kDefaultBufferSize];
   int deflate_decode_size = kDefaultBufferSize;
-  filter->ReadData(deflate_decode_buffer, &deflate_decode_size);
+  filter_->ReadData(deflate_decode_buffer, &deflate_decode_size);
 
   // Compare the decoding result with source data
   EXPECT_TRUE(deflate_decode_size == source_len());
   EXPECT_EQ(memcmp(source_buffer(), deflate_decode_buffer, source_len()), 0);
 }
 
 // Basic scenario: decoding gzip data with big enough buffer.
 TEST_F(GZipUnitTest, DecodeGZip) {
   // Decode the compressed data with filter
-  std::vector<Filter::FilterType> filter_types;
-  filter_types.push_back(Filter::FILTER_TYPE_GZIP);
-  net::MockFilterContext filter_context(kDefaultBufferSize);
-  scoped_ptr<Filter> filter(Filter::Factory(filter_types, filter_context));
-  ASSERT_TRUE(filter.get());
-  memcpy(filter->stream_buffer()->data(), gzip_encode_buffer_,
+  InitFilter(Filter::FILTER_TYPE_GZIP);
+  memcpy(filter_->stream_buffer()->data(), gzip_encode_buffer_,
          gzip_encode_len_);
-  filter->FlushStreamBuffer(gzip_encode_len_);
+  filter_->FlushStreamBuffer(gzip_encode_len_);
 
   char gzip_decode_buffer[kDefaultBufferSize];
   int gzip_decode_size = kDefaultBufferSize;
-  filter->ReadData(gzip_decode_buffer, &gzip_decode_size);
+  filter_->ReadData(gzip_decode_buffer, &gzip_decode_size);
 
   // Compare the decoding result with source data
   EXPECT_TRUE(gzip_decode_size == source_len());
   EXPECT_EQ(memcmp(source_buffer(), gzip_decode_buffer, source_len()), 0);
 }
 
 // Tests we can call filter repeatedly to get all the data decoded.
 // To do that, we create a filter with a small buffer that can not hold all
 // the input data.
 TEST_F(GZipUnitTest, DecodeWithSmallBuffer) {
-  std::vector<Filter::FilterType> filter_types;
-  filter_types.push_back(Filter::FILTER_TYPE_DEFLATE);
-  net::MockFilterContext filter_context(kSmallBufferSize);
-  scoped_ptr<Filter> filter(Filter::Factory(filter_types, filter_context));
-  ASSERT_TRUE(filter.get());
-  DecodeAndCompareWithFilter(filter.get(), source_buffer(), source_len(),
+  InitFilterWithBufferSize(Filter::FILTER_TYPE_DEFLATE, kSmallBufferSize);
+  DecodeAndCompareWithFilter(filter_.get(), source_buffer(), source_len(),
                              deflate_encode_buffer_, deflate_encode_len_,
                              kDefaultBufferSize);
 }
 
 // Tests we can still decode with just 1 byte buffer in the filter.
 // The purpose of this tests are two: (1) Verify filter can parse partial GZip
 // header correctly. (2) Sometimes the filter will consume input without
 // generating output. Verify filter can handle it correctly.
 TEST_F(GZipUnitTest, DecodeWithOneByteBuffer) {
-  std::vector<Filter::FilterType> filter_types;
-  filter_types.push_back(Filter::FILTER_TYPE_GZIP);
-  net::MockFilterContext filter_context(1);
-  scoped_ptr<Filter> filter(Filter::Factory(filter_types, filter_context));
-  ASSERT_TRUE(filter.get());
-  DecodeAndCompareWithFilter(filter.get(), source_buffer(), source_len(),
+  InitFilterWithBufferSize(Filter::FILTER_TYPE_GZIP, 1);
+  DecodeAndCompareWithFilter(filter_.get(), source_buffer(), source_len(),
                              gzip_encode_buffer_, gzip_encode_len_,
                              kDefaultBufferSize);
 }
 
 // Tests we can decode when caller has small buffer to read out from filter.
 TEST_F(GZipUnitTest, DecodeWithSmallOutputBuffer) {
-  std::vector<Filter::FilterType> filter_types;
-  filter_types.push_back(Filter::FILTER_TYPE_DEFLATE);
-  net::MockFilterContext filter_context(kDefaultBufferSize);
-  scoped_ptr<Filter> filter(Filter::Factory(filter_types, filter_context));
-  ASSERT_TRUE(filter.get());
-  DecodeAndCompareWithFilter(filter.get(), source_buffer(), source_len(),
+  InitFilter(Filter::FILTER_TYPE_DEFLATE);
+  DecodeAndCompareWithFilter(filter_.get(), source_buffer(), source_len(),
                              deflate_encode_buffer_, deflate_encode_len_,
                              kSmallBufferSize);
 }
 
 // Tests we can still decode with just 1 byte buffer in the filter and just 1
 // byte buffer in the caller.
 TEST_F(GZipUnitTest, DecodeWithOneByteInputAndOutputBuffer) {
-  std::vector<Filter::FilterType> filter_types;
-  filter_types.push_back(Filter::FILTER_TYPE_GZIP);
-  net::MockFilterContext filter_context(1);
-  scoped_ptr<Filter> filter(Filter::Factory(filter_types, filter_context));
-  ASSERT_TRUE(filter.get());
-  DecodeAndCompareWithFilter(filter.get(), source_buffer(), source_len(),
+  InitFilterWithBufferSize(Filter::FILTER_TYPE_GZIP, 1);
+  DecodeAndCompareWithFilter(filter_.get(), source_buffer(), source_len(),
                              gzip_encode_buffer_, gzip_encode_len_, 1);
 }
 
 // Decoding deflate stream with corrupted data.
 TEST_F(GZipUnitTest, DecodeCorruptedData) {
   char corrupt_data[kDefaultBufferSize];
   int corrupt_data_len = deflate_encode_len_;
   memcpy(corrupt_data, deflate_encode_buffer_, deflate_encode_len_);
 
   int pos = corrupt_data_len / 2;
   corrupt_data[pos] = !corrupt_data[pos];
 
   // Decode the corrupted data with filter
-  std::vector<Filter::FilterType> filter_types;
-  filter_types.push_back(Filter::FILTER_TYPE_DEFLATE);
-  net::MockFilterContext filter_context(kDefaultBufferSize);
-  scoped_ptr<Filter> filter(Filter::Factory(filter_types, filter_context));
-  ASSERT_TRUE(filter.get());
+  InitFilter(Filter::FILTER_TYPE_DEFLATE);
   char corrupt_decode_buffer[kDefaultBufferSize];
   int corrupt_decode_size = kDefaultBufferSize;
 
-  int code = DecodeAllWithFilter(filter.get(), corrupt_data, corrupt_data_len,
+  int code = DecodeAllWithFilter(filter_.get(), corrupt_data, corrupt_data_len,
                                  corrupt_decode_buffer, &corrupt_decode_size);
 
   // Expect failures
   EXPECT_TRUE(code == Filter::FILTER_ERROR);
 }
 
 // Decoding deflate stream with missing data.
 TEST_F(GZipUnitTest, DecodeMissingData) {
   char corrupt_data[kDefaultBufferSize];
   int corrupt_data_len = deflate_encode_len_;
   memcpy(corrupt_data, deflate_encode_buffer_, deflate_encode_len_);
 
   int pos = corrupt_data_len / 2;
   int len = corrupt_data_len - pos - 1;
   memmove(&corrupt_data[pos], &corrupt_data[pos+1], len);
   --corrupt_data_len;
 
   // Decode the corrupted data with filter
-  std::vector<Filter::FilterType> filter_types;
-  filter_types.push_back(Filter::FILTER_TYPE_DEFLATE);
-  net::MockFilterContext filter_context(kDefaultBufferSize);
-  scoped_ptr<Filter> filter(Filter::Factory(filter_types, filter_context));
-  ASSERT_TRUE(filter.get());
+  InitFilter(Filter::FILTER_TYPE_DEFLATE);
   char corrupt_decode_buffer[kDefaultBufferSize];
   int corrupt_decode_size = kDefaultBufferSize;
 
-  int code = DecodeAllWithFilter(filter.get(), corrupt_data, corrupt_data_len,
+  int code = DecodeAllWithFilter(filter_.get(), corrupt_data, corrupt_data_len,
                                  corrupt_decode_buffer, &corrupt_decode_size);
 
   // Expect failures
   EXPECT_EQ(Filter::FILTER_ERROR, code);
 }
 
 // Decoding gzip stream with corrupted header.
 TEST_F(GZipUnitTest, DecodeCorruptedHeader) {
   char corrupt_data[kDefaultBufferSize];
   int corrupt_data_len = gzip_encode_len_;
   memcpy(corrupt_data, gzip_encode_buffer_, gzip_encode_len_);
 
   corrupt_data[2] = !corrupt_data[2];
 
   // Decode the corrupted data with filter
-  std::vector<Filter::FilterType> filter_types;
-  filter_types.push_back(Filter::FILTER_TYPE_GZIP);
-  net::MockFilterContext filter_context(kDefaultBufferSize);
-  scoped_ptr<Filter> filter(Filter::Factory(filter_types, filter_context));
-  ASSERT_TRUE(filter.get());
+  InitFilter(Filter::FILTER_TYPE_GZIP);
   char corrupt_decode_buffer[kDefaultBufferSize];
   int corrupt_decode_size = kDefaultBufferSize;
 
-  int code = DecodeAllWithFilter(filter.get(), corrupt_data, corrupt_data_len,
+  int code = DecodeAllWithFilter(filter_.get(), corrupt_data, corrupt_data_len,
                                  corrupt_decode_buffer, &corrupt_decode_size);
 
   // Expect failures
   EXPECT_TRUE(code == Filter::FILTER_ERROR);
 }
-
-}  // namespace