Use FilterContext to allow filters to access URLRequestJob data...

net/base/bzip2_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>
 
 #include "base/file_util.h"
 #include "base/path_service.h"
 #include "base/scoped_ptr.h"
 #include "net/base/bzip2_filter.h"
+#include "net/base/filter_unittest.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "testing/platform_test.h"
 #include "third_party/bzip2/bzlib.h"
 
 namespace {
 
 const char* kExtraData = "Test Data, More Test Data, Even More Data of Test";
 const int kExtraDataBufferSize = 49;
 const int kDefaultBufferSize = 4096;
 const int kSmallBufferSize = 128;
@@ skipping 155 matching lines @@
   scoped_ptr<bz_stream> bzip2_data_stream_;
   char* bzip2_encode_buffer_;
   int bzip2_encode_len_;
 };
 
 // Basic scenario: decoding bzip2 data with big enough buffer.
 TEST_F(BZip2FilterUnitTest, DecodeBZip2) {
   // Decode the compressed data with filter
   std::vector<Filter::FilterType> filter_types;
   filter_types.push_back(Filter::FILTER_TYPE_BZIP2);
-  scoped_ptr<Filter> filter(Filter::Factory(filter_types, kDefaultBufferSize));
+  MockFilterContext filter_context(kDefaultBufferSize);
+  scoped_ptr<Filter> filter(Filter::Factory(filter_types, filter_context));
   ASSERT_TRUE(filter.get());
   memcpy(filter->stream_buffer()->data(), bzip2_encode_buffer_,
          bzip2_encode_len_);
   filter->FlushStreamBuffer(bzip2_encode_len_);
 
   char bzip2_decode_buffer[kDefaultBufferSize];
   int bzip2_decode_size = kDefaultBufferSize;
   Filter::FilterStatus result =
       filter->ReadData(bzip2_decode_buffer, &bzip2_decode_size);
   ASSERT_EQ(Filter::FILTER_DONE, result);
 
   // Compare the decoding result with source data
   EXPECT_TRUE(bzip2_decode_size == source_len());
   EXPECT_EQ(memcmp(source_buffer(), bzip2_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(BZip2FilterUnitTest, DecodeWithSmallInputBuffer) {
   std::vector<Filter::FilterType> filter_types;
   filter_types.push_back(Filter::FILTER_TYPE_BZIP2);
-  scoped_ptr<Filter> filter(Filter::Factory(filter_types, kSmallBufferSize));
+  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(),
                              bzip2_encode_buffer_, bzip2_encode_len_,
                              kDefaultBufferSize, false);
 }
 
 // Tests we can decode when caller has small buffer to read out from filter.
 TEST_F(BZip2FilterUnitTest, DecodeWithSmallOutputBuffer) {
   std::vector<Filter::FilterType> filter_types;
   filter_types.push_back(Filter::FILTER_TYPE_BZIP2);
-  scoped_ptr<Filter> filter(Filter::Factory(filter_types, kDefaultBufferSize));
+  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(),
                              bzip2_encode_buffer_, bzip2_encode_len_,
                              kSmallBufferSize, false);
 }
 
 // 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 BZip2
 // header correctly. (2) Sometimes the filter will consume input without
 // generating output. Verify filter can handle it correctly.
 TEST_F(BZip2FilterUnitTest, DecodeWithOneByteInputBuffer) {
   std::vector<Filter::FilterType> filter_types;
   filter_types.push_back(Filter::FILTER_TYPE_BZIP2);
-  scoped_ptr<Filter> filter(Filter::Factory(filter_types, 1));
+  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(),
                              bzip2_encode_buffer_, bzip2_encode_len_,
                              kDefaultBufferSize, false);
 }
 
 // Tests we can still decode with just 1 byte buffer in the filter and just 1
 // byte buffer in the caller.
 TEST_F(BZip2FilterUnitTest, DecodeWithOneByteInputAndOutputBuffer) {
   std::vector<Filter::FilterType> filter_types;
   filter_types.push_back(Filter::FILTER_TYPE_BZIP2);
-  scoped_ptr<Filter> filter(Filter::Factory(filter_types, 1));
+  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(),
                              bzip2_encode_buffer_, bzip2_encode_len_, 1, false);
 }
 
 // Decoding bzip2 stream with corrupted data.
 TEST_F(BZip2FilterUnitTest, DecodeCorruptedData) {
   char corrupt_data[kDefaultBufferSize];
   int corrupt_data_len = bzip2_encode_len_;
   memcpy(corrupt_data, bzip2_encode_buffer_, bzip2_encode_len_);
 
   char corrupt_decode_buffer[kDefaultBufferSize];
   int corrupt_decode_size = kDefaultBufferSize;
 
   // Decode the correct data with filter
   std::vector<Filter::FilterType> filter_types;
   filter_types.push_back(Filter::FILTER_TYPE_BZIP2);
-  scoped_ptr<Filter> filter1(Filter::Factory(filter_types, kDefaultBufferSize));
+  MockFilterContext filter_context(kDefaultBufferSize);
+  scoped_ptr<Filter> filter1(Filter::Factory(filter_types, filter_context));
   ASSERT_TRUE(filter1.get());
 
   Filter::FilterStatus code = DecodeAllWithFilter(filter1.get(),
                                                   corrupt_data,
                                                   corrupt_data_len,
                                                   corrupt_decode_buffer,
                                                   &corrupt_decode_size);
 
   // Expect failures
   EXPECT_TRUE(code == Filter::FILTER_DONE);
 
   // Decode the corrupted data with filter
-  scoped_ptr<Filter> filter2(Filter::Factory(filter_types, kDefaultBufferSize));
+  scoped_ptr<Filter> filter2(Filter::Factory(filter_types, filter_context));
   ASSERT_TRUE(filter2.get());
 
   int pos = corrupt_data_len / 2;
   corrupt_data[pos] = !corrupt_data[pos];
 
   code = DecodeAllWithFilter(filter2.get(),
                              corrupt_data,
                              corrupt_data_len,
                              corrupt_decode_buffer,
                              &corrupt_decode_size);
 
   // Expect failures
   EXPECT_TRUE(code != Filter::FILTER_DONE);
 }
 
 // Decoding bzip2 stream with missing data.
 TEST_F(BZip2FilterUnitTest, DecodeMissingData) {
   char corrupt_data[kDefaultBufferSize];
   int corrupt_data_len = bzip2_encode_len_;
   memcpy(corrupt_data, bzip2_encode_buffer_, bzip2_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_BZIP2);
-  scoped_ptr<Filter> filter(Filter::Factory(filter_types, kDefaultBufferSize));
+  MockFilterContext filter_context(kDefaultBufferSize);
+  scoped_ptr<Filter> filter(Filter::Factory(filter_types, filter_context));
   ASSERT_TRUE(filter.get());
   char corrupt_decode_buffer[kDefaultBufferSize];
   int corrupt_decode_size = kDefaultBufferSize;
 
   Filter::FilterStatus code = DecodeAllWithFilter(filter.get(),
                                                   corrupt_data,
                                                   corrupt_data_len,
                                                   corrupt_decode_buffer,
                                                   &corrupt_decode_size);
   // Expect failures
   EXPECT_TRUE(code != Filter::FILTER_DONE);
 }
 
 // Decoding bzip2 stream with corrupted header.
 TEST_F(BZip2FilterUnitTest, DecodeCorruptedHeader) {
   char corrupt_data[kDefaultBufferSize];
   int corrupt_data_len = bzip2_encode_len_;
   memcpy(corrupt_data, bzip2_encode_buffer_, bzip2_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_BZIP2);
-  scoped_ptr<Filter> filter(Filter::Factory(filter_types, kDefaultBufferSize));
+  MockFilterContext filter_context(kDefaultBufferSize);
+  scoped_ptr<Filter> filter(Filter::Factory(filter_types, filter_context));
   ASSERT_TRUE(filter.get());
   char corrupt_decode_buffer[kDefaultBufferSize];
   int corrupt_decode_size = kDefaultBufferSize;
 
   Filter::FilterStatus code = DecodeAllWithFilter(filter.get(),
                                                   corrupt_data,
                                                   corrupt_data_len,
                                                   corrupt_decode_buffer,
                                                   &corrupt_decode_size);
 
   // Expect failures
   EXPECT_TRUE(code == Filter::FILTER_ERROR);
 }
 
 // Tests we can decode all compress data and get extra data which is
 // appended  to compress data stream by some server when it finish
 // sending compress data.
 TEST_F(BZip2FilterUnitTest, DecodeWithExtraDataAndSmallOutputBuffer) {
   char more_data[kDefaultBufferSize + kExtraDataBufferSize];
   int more_data_len = bzip2_encode_len_ + kExtraDataBufferSize;
   memcpy(more_data, bzip2_encode_buffer_, bzip2_encode_len_);
   memcpy(more_data + bzip2_encode_len_, kExtraData, kExtraDataBufferSize);
 
   std::vector<Filter::FilterType> filter_types;
   filter_types.push_back(Filter::FILTER_TYPE_BZIP2);
-  scoped_ptr<Filter> filter(Filter::Factory(filter_types, kDefaultBufferSize));
+  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() + kExtraDataBufferSize,
                              more_data,
                              more_data_len,
                              kSmallBufferSize,
                              true);
 }
 
 TEST_F(BZip2FilterUnitTest, DecodeWithExtraDataAndSmallInputBuffer) {
   char more_data[kDefaultBufferSize + kExtraDataBufferSize];
   int more_data_len = bzip2_encode_len_ + kExtraDataBufferSize;
   memcpy(more_data, bzip2_encode_buffer_, bzip2_encode_len_);
   memcpy(more_data + bzip2_encode_len_, kExtraData, kExtraDataBufferSize);
 
   std::vector<Filter::FilterType> filter_types;
   filter_types.push_back(Filter::FILTER_TYPE_BZIP2);
-  scoped_ptr<Filter> filter(Filter::Factory(filter_types, kSmallBufferSize));
+  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() + kExtraDataBufferSize,
                              more_data,
                              more_data_len,
                              kDefaultBufferSize,
                              true);
 }
 
 }  // namespace