Remove net::Filter code

net/filter/brotli_filter_unittest.cc

Index: net/filter/brotli_filter_unittest.cc
diff --git a/net/filter/brotli_filter_unittest.cc b/net/filter/brotli_filter_unittest.cc
deleted file mode 100644
index d9feca161c002d028ac821ee8674666dcfb3632a..0000000000000000000000000000000000000000
--- a/net/filter/brotli_filter_unittest.cc
+++ /dev/null
@@ -1,271 +0,0 @@
-// Copyright 2015 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 "net/filter/brotli_filter.h"
-
-#include <memory>
-
-#include "base/files/file_util.h"
-#include "base/path_service.h"
-#include "net/base/io_buffer.h"
-#include "net/filter/mock_filter_context.h"
-#include "testing/gtest/include/gtest/gtest.h"
-#include "testing/platform_test.h"
-
-namespace {
-const int kDefaultBufferSize = 4096;
-const int kSmallBufferSize = 128;
-}  // namespace
-
-namespace net {
-
-// These tests use the path service, which uses autoreleased objects on the
-// Mac, so this needs to be a PlatformTest.
-class BrotliUnitTest : public PlatformTest {
- protected:
-  void SetUp() override {
-    PlatformTest::SetUp();
-
-    // Get the path of data directory.
-    base::FilePath data_dir;
-    PathService::Get(base::DIR_SOURCE_ROOT, &data_dir);
-    data_dir = data_dir.AppendASCII("net");
-    data_dir = data_dir.AppendASCII("data");
-    data_dir = data_dir.AppendASCII("filter_unittests");
-
-    // Read data from the original file into buffer.
-    base::FilePath file_path;
-    file_path = data_dir.AppendASCII("google.txt");
-    ASSERT_TRUE(base::ReadFileToString(file_path, &source_buffer_));
-
-    // Read data from the encoded file into buffer.
-    base::FilePath encoded_file_path;
-    encoded_file_path = data_dir.AppendASCII("google.br");
-    ASSERT_TRUE(base::ReadFileToString(encoded_file_path, &encoded_buffer_));
-    ASSERT_GE(kDefaultBufferSize, static_cast<int>(encoded_buffer_.size()));
-  }
-
-  // Use filter to decode compressed data, and compare the decoded result with
-  // the orginal data.
-  // Parameters: |source| and |source_len| are original data and its size.
-  // |encoded_source| and |encoded_source_len| are compressed data and its size.
-  // |output_buffer_size| specifies the size of buffer to read out data from
-  // filter.
-  void DecodeAndCompareWithFilter(Filter* filter,
-                                  const char* source,
-                                  int source_len,
-                                  const char* encoded_source,
-                                  int encoded_source_len,
-                                  int output_buffer_size) {
-    // Make sure we have enough space to hold the decoding output.
-    ASSERT_GE(kDefaultBufferSize, source_len);
-    ASSERT_GE(kDefaultBufferSize, output_buffer_size);
-
-    char decode_buffer[kDefaultBufferSize];
-    char* decode_next = decode_buffer;
-    int decode_avail_size = kDefaultBufferSize;
-
-    const char* encode_next = encoded_source;
-    int encode_avail_size = encoded_source_len;
-
-    int code = Filter::FILTER_OK;
-    while (code != Filter::FILTER_DONE) {
-      int encode_data_len =
-          std::min(encode_avail_size, filter->stream_buffer_size());
-      memcpy(filter->stream_buffer()->data(), encode_next, encode_data_len);
-      filter->FlushStreamBuffer(encode_data_len);
-      encode_next += encode_data_len;
-      encode_avail_size -= encode_data_len;
-
-      while (true) {
-        int decode_data_len = std::min(decode_avail_size, output_buffer_size);
-
-        code = filter->ReadData(decode_next, &decode_data_len);
-        decode_next += decode_data_len;
-        decode_avail_size -= decode_data_len;
-
-        ASSERT_NE(Filter::FILTER_ERROR, code);
-
-        if (code == Filter::FILTER_NEED_MORE_DATA ||
-            code == Filter::FILTER_DONE) {
-          break;
-        }
-      }
-    }
-
-    // Compare the decoding result with source data
-    int decode_total_data_len = kDefaultBufferSize - decode_avail_size;
-    EXPECT_EQ(source_len, decode_total_data_len);
-    EXPECT_EQ(memcmp(source, decode_buffer, source_len), 0);
-  }
-
-  // Unsafe function to use filter to decode compressed data.
-  // Parameters: |source| and |source_len| are compressed data and its size.
-  // |dest| is the buffer for decoding results. Upon entry, |*dest_len| is the
-  // size of the output 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() {
-    std::vector<Filter::FilterType> filter_types;
-    filter_types.push_back(Filter::FILTER_TYPE_BROTLI);
-    filter_ = Filter::Factory(filter_types, filter_context_);
-    ASSERT_TRUE(filter_.get());
-    ASSERT_LE(kDefaultBufferSize, filter_->stream_buffer_size());
-  }
-
-  void InitFilterWithBufferSize(int buffer_size) {
-    std::vector<Filter::FilterType> filter_types;
-    filter_types.push_back(Filter::FILTER_TYPE_BROTLI);
-    filter_ =
-        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()); }
-
-  const char* encoded_buffer() const { return encoded_buffer_.data(); }
-  int encoded_len() const { return static_cast<int>(encoded_buffer_.size()); }
-
-  std::unique_ptr<Filter> filter_;
-
- private:
-  MockFilterContext filter_context_;
-  std::string source_buffer_;
-  std::string encoded_buffer_;
-};
-
-// Basic scenario: decoding brotli data with big enough buffer.
-TEST_F(BrotliUnitTest, DecodeBrotli) {
-  InitFilter();
-  memcpy(filter_->stream_buffer()->data(), encoded_buffer(), encoded_len());
-  filter_->FlushStreamBuffer(encoded_len());
-
-  ASSERT_GE(kDefaultBufferSize, source_len());
-  char decode_buffer[kDefaultBufferSize];
-  int decode_size = kDefaultBufferSize;
-  filter_->ReadData(decode_buffer, &decode_size);
-
-  // Compare the decoding result with source data
-  EXPECT_EQ(source_len(), decode_size);
-  EXPECT_EQ(memcmp(source_buffer(), 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(BrotliUnitTest, DecodeWithSmallBuffer) {
-  InitFilterWithBufferSize(kSmallBufferSize);
-  EXPECT_EQ(kSmallBufferSize, filter_->stream_buffer_size());
-  DecodeAndCompareWithFilter(filter_.get(), source_buffer(), source_len(),
-                             encoded_buffer(), encoded_len(),
-                             kDefaultBufferSize);
-}
-
-// Tests we can still decode with just 1 byte buffer in the filter.
-// The purpose of this test: sometimes the filter will consume input without
-// generating output. Verify filter can handle it correctly.
-TEST_F(BrotliUnitTest, DecodeWithOneByteBuffer) {
-  InitFilterWithBufferSize(1);
-  EXPECT_EQ(1, filter_->stream_buffer_size());
-  DecodeAndCompareWithFilter(filter_.get(), source_buffer(), source_len(),
-                             encoded_buffer(), encoded_len(),
-                             kDefaultBufferSize);
-}
-
-// Tests we can decode when caller has small buffer to read out from filter.
-TEST_F(BrotliUnitTest, DecodeWithSmallOutputBuffer) {
-  InitFilter();
-  DecodeAndCompareWithFilter(filter_.get(), source_buffer(), source_len(),
-                             encoded_buffer(), encoded_len(), kSmallBufferSize);
-}
-
-// Tests we can decode when caller has small buffer and input is also broken
-// into small parts. This may uncover some corner cases that doesn't happen with
-// one-byte buffers.
-TEST_F(BrotliUnitTest, DecodeWithSmallInputAndOutputBuffer) {
-  InitFilterWithBufferSize(kSmallBufferSize);
-  DecodeAndCompareWithFilter(filter_.get(), source_buffer(), source_len(),
-                             encoded_buffer(), encoded_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(BrotliUnitTest, DecodeWithOneByteInputAndOutputBuffer) {
-  InitFilterWithBufferSize(1);
-  EXPECT_EQ(1, filter_->stream_buffer_size());
-  DecodeAndCompareWithFilter(filter_.get(), source_buffer(), source_len(),
-                             encoded_buffer(), encoded_len(), 1);
-}
-
-// Decoding deflate stream with corrupted data.
-TEST_F(BrotliUnitTest, DecodeCorruptedData) {
-  char corrupt_data[kDefaultBufferSize];
-  int corrupt_data_len = encoded_len();
-  memcpy(corrupt_data, encoded_buffer(), encoded_len());
-
-  int pos = corrupt_data_len / 2;
-  corrupt_data[pos] = !corrupt_data[pos];
-
-  // Decode the corrupted data with filter
-  InitFilter();
-  char corrupt_decode_buffer[kDefaultBufferSize];
-  int corrupt_decode_size = kDefaultBufferSize;
-
-  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 deflate stream with missing data.
-TEST_F(BrotliUnitTest, DecodeMissingData) {
-  char corrupt_data[kDefaultBufferSize];
-  int corrupt_data_len = encoded_len();
-  memcpy(corrupt_data, encoded_buffer(), encoded_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
-  InitFilter();
-  char corrupt_decode_buffer[kDefaultBufferSize];
-  int corrupt_decode_size = kDefaultBufferSize;
-
-  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 brotli stream with empty output data.
-TEST_F(BrotliUnitTest, DecodeEmptyData) {
-  char data[1] = {6};  // WBITS = 16, ISLAST = 1, ISLASTEMPTY = 1
-  int data_len = 1;
-
-  InitFilter();
-  char decode_buffer[kDefaultBufferSize];
-  int decode_size = kDefaultBufferSize;
-  int code = DecodeAllWithFilter(filter_.get(), data, data_len, decode_buffer,
-                                 &decode_size);
-
-  // Expect success / empty output.
-  EXPECT_EQ(Filter::FILTER_DONE, code);
-  EXPECT_EQ(0, decode_size);
-}
-
-}  // namespace net