Clean up filter and content encoding handling ...

net/base/sdch_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.
 
-// TODO(jar): Change file name to *_unittest.cc (with double "t').
-
 #include <algorithm>
 #include <string>
 #include <vector>
 
 #include "base/logging.h"
 #include "base/scoped_ptr.h"
 #include "net/base/filter.h"
 #include "net/base/sdch_filter.h"
 #include "net/url_request/url_request_http_job.cc"
 #include "testing/gtest/include/gtest/gtest.h"
@@ skipping 106 matching lines @@
     dictionary.append("\n");
   }
   dictionary.append("\n");
   dictionary.append(kTestVcdiffDictionary, sizeof(kTestVcdiffDictionary) - 1);
   return dictionary;
 }
 
 //------------------------------------------------------------------------------
 
 TEST_F(SdchFilterTest, BasicBadDictionary) {
-  std::vector<std::string> filters;
-  filters.push_back("sdch");
+  std::vector<Filter::FilterType> filter_types;
+  filter_types.push_back(Filter::FILTER_TYPE_SDCH);
   const int kInputBufferSize(30);
   char output_buffer[20];
-  scoped_ptr<Filter> filter(Filter::Factory(filters, "missing-mime",
-                                            kInputBufferSize));
+  scoped_ptr<Filter> filter(Filter::Factory(filter_types, kInputBufferSize));
   std::string url_string("http://ignore.com");
   filter->SetURL(GURL(url_string));
 
 
   // 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);
@@ skipping 69 matching lines @@
   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<std::string> filters;
-  filters.push_back("sdch");
+  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);
-  scoped_ptr<Filter> filter(Filter::Factory(filters, "missing-mime",
-                                            kInputBufferSize));
+  scoped_ptr<Filter> filter(Filter::Factory(filter_types, kInputBufferSize));
   filter->SetURL(url);
 
   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_);
 
   // Decode with really small buffers (size 1) to check for edge effects.
-  filter.reset((Filter::Factory(filters, "missing-mime", kInputBufferSize)));
+  filter.reset((Filter::Factory(filter_types, kInputBufferSize)));
   filter->SetURL(url);
 
   feed_block_size = 1;
   output_block_size = 1;
   output.clear();
   EXPECT_TRUE(FilterTestData(compressed, feed_block_size, output_block_size,
                              filter.get(), &output));
   EXPECT_EQ(output, expanded_);
 }
 
 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<std::string> filters;
-  filters.push_back("sdch");
+  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 CanSet() in the sdch_manager_->
-  scoped_ptr<Filter> filter((Filter::Factory(filters, "missing-mime",
-                                             kInputBufferSize)));
+  scoped_ptr<Filter> filter((Filter::Factory(filter_types,  kInputBufferSize)));
   GURL wrong_domain_url("http://www.wrongdomain.com");
   filter->SetURL(wrong_domain_url);
 
   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 14 matching lines @@
   EXPECT_TRUE(sdch_manager_->AddSdchDictionary(dictionary, url));
 
   // 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<std::string> filters;
-  filters.push_back("sdch");
+  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.
-  scoped_ptr<Filter> filter((Filter::Factory(filters, "missing-mime",
-                            kInputBufferSize)));
+  scoped_ptr<Filter> filter((Filter::Factory(filter_types, kInputBufferSize)));
   filter->SetURL(GURL(url_string + path));
 
   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_);
 
   // Test decode the path data, arriving from a invalid path.
-  filter.reset((Filter::Factory(filters, "missing-mime", kInputBufferSize)));
+  filter.reset((Filter::Factory(filter_types, kInputBufferSize)));
   filter->SetURL(GURL(url_string));
 
   feed_block_size = 100;
   output_block_size = 100;
   output.clear();
   EXPECT_FALSE(FilterTestData(compressed_for_path, feed_block_size,
                               output_block_size, filter.get(), &output));
   EXPECT_EQ(output.size(), 0u);  // No output written.
 
   EXPECT_FALSE(SdchManager::Global()->IsInSupportedDomain(GURL(url_string)));
@@ skipping 15 matching lines @@
   // Create a dictionary with a port restriction, by prefixing old dictionary.
   const std::string port("502");
   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<std::string> filters;
-  filters.push_back("sdch");
+  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.
-  scoped_ptr<Filter> filter((Filter::Factory(filters, "missing-mime",
-                                             kInputBufferSize)));
+  scoped_ptr<Filter> filter((Filter::Factory(filter_types, kInputBufferSize)));
   filter->SetURL(GURL(url_string + ":" + port));
 
   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_);
 
   // Test decode the port data, arriving from a valid (default) port.
-  filter.reset((Filter::Factory(filters, "missing-mime", kInputBufferSize)));
+  filter.reset((Filter::Factory(filter_types, kInputBufferSize)));
   filter->SetURL(GURL(url_string));  // Default port.
 
   feed_block_size = 100;
   output_block_size = 100;
   output.clear();
   EXPECT_TRUE(FilterTestData(compressed_for_port, feed_block_size,
                              output_block_size, filter.get(), &output));
   EXPECT_EQ(output, expanded_);
 
   // Test decode the port data, arriving from a invalid port.
-  filter.reset((Filter::Factory(filters, "missing-mime", kInputBufferSize)));
+  filter.reset((Filter::Factory(filter_types, kInputBufferSize)));
   filter->SetURL(GURL(url_string + ":" + port + "1"));
 
   feed_block_size = 100;
   output_block_size = 100;
   output.clear();
   EXPECT_FALSE(FilterTestData(compressed_for_port, feed_block_size,
                               output_block_size, filter.get(), &output));
   EXPECT_EQ(output.size(), 0u);  // No output written.
 
   EXPECT_FALSE(SdchManager::Global()->IsInSupportedDomain(GURL(url_string)));
@@ skipping 70 matching lines @@
 
   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<std::string> filters;
-  filters.push_back("sdch");
-  filters.push_back("gzip");
+  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 int kInputBufferSize(100);
-  scoped_ptr<Filter> filter(Filter::Factory(filters, "missing-mime",
-                                            kInputBufferSize));
+  scoped_ptr<Filter> filter(Filter::Factory(filter_types, kInputBufferSize));
   filter->SetURL(url);
 
   // 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));
 
   size_t feed_block_size = 100;
   size_t output_block_size = 100;
   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 tiny buffer to cover edge effects.
-  filter.reset(Filter::Factory(filters, "missing-mime", kInputBufferSize));
+  filter.reset(Filter::Factory(filter_types, kInputBufferSize));
   filter->SetURL(url);
 
   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 usethe gzipped sdch content.
+  // Only claim to have sdch content, but really use the gzipped sdch content.
   // System should automatically add the missing (optional) gzip.
-  std::vector<std::string> filters;
-  filters.push_back("sdch");
+  std::vector<Filter::FilterType> filter_types;
+  filter_types.push_back(Filter::FILTER_TYPE_SDCH);
+  Filter::FixupEncodingTypes(true, "anything/mime", &filter_types);
 
   // First try with a large buffer (larger than test input, or compressed data).
   const int kInputBufferSize(100);
-  scoped_ptr<Filter> filter(Filter::Factory(filters, "missing-mime",
-                            kInputBufferSize));
+  scoped_ptr<Filter> filter(Filter::Factory(filter_types, kInputBufferSize));
   filter->SetURL(url);
 
   // 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));
 
   size_t feed_block_size = 100;
   size_t output_block_size = 100;
   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 tiny buffer to cover edge effects.
-  filter.reset(Filter::Factory(filters, "missing-mime", kInputBufferSize));
+  filter.reset(Filter::Factory(filter_types, kInputBufferSize));
   filter->SetURL(url);
 
   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_);
 }
 
@@ skipping 13 matching lines @@
   GURL google_url("http://www.google.com");
 
   SdchManager::BlacklistDomain(test_url);
   EXPECT_FALSE(SdchManager::Global()->IsInSupportedDomain(test_url));
   EXPECT_TRUE(SdchManager::Global()->IsInSupportedDomain(google_url));
 
   SdchManager::BlacklistDomain(google_url);
   EXPECT_FALSE(SdchManager::Global()->IsInSupportedDomain(test_url));
   EXPECT_FALSE(SdchManager::Global()->IsInSupportedDomain(google_url));
 }
-
-
-// TODO(jar): move this sort of test into filter_unittest.cc, or
-// url_request_http_job_unittest.cc if that is more applicable after refactoring
-// to use array of enums rather than array of strings to express content
-// encodings.
-TEST_F(SdchFilterTest, ContentTypeId) {
-  // Check for basic translation of Content-Encoding, including case variations.
-  EXPECT_EQ(Filter::FILTER_TYPE_DEFLATE,
-            Filter::ConvertEncodingToType("deflate", "nothing"));
-  EXPECT_EQ(Filter::FILTER_TYPE_DEFLATE,
-            Filter::ConvertEncodingToType("deflAte", "nothing"));
-  EXPECT_EQ(Filter::FILTER_TYPE_GZIP,
-            Filter::ConvertEncodingToType("gzip", "nothing"));
-  EXPECT_EQ(Filter::FILTER_TYPE_GZIP,
-            Filter::ConvertEncodingToType("GzIp", "nothing"));
-  EXPECT_EQ(Filter::FILTER_TYPE_GZIP,
-            Filter::ConvertEncodingToType("x-gzip", "nothing"));
-  EXPECT_EQ(Filter::FILTER_TYPE_GZIP,
-            Filter::ConvertEncodingToType("X-GzIp", "nothing"));
-  EXPECT_EQ(Filter::FILTER_TYPE_BZIP2,
-            Filter::ConvertEncodingToType("bzip2", "nothing"));
-  EXPECT_EQ(Filter::FILTER_TYPE_BZIP2,
-            Filter::ConvertEncodingToType("BZiP2", "nothing"));
-  EXPECT_EQ(Filter::FILTER_TYPE_BZIP2,
-            Filter::ConvertEncodingToType("x-bzip2", "nothing"));
-  EXPECT_EQ(Filter::FILTER_TYPE_BZIP2,
-            Filter::ConvertEncodingToType("X-BZiP2", "nothing"));
-  EXPECT_EQ(Filter::FILTER_TYPE_SDCH,
-            Filter::ConvertEncodingToType("sdch", "nothing"));
-  EXPECT_EQ(Filter::FILTER_TYPE_SDCH,
-            Filter::ConvertEncodingToType("sDcH", "nothing"));
-  EXPECT_EQ(Filter::FILTER_TYPE_UNSUPPORTED,
-            Filter::ConvertEncodingToType("weird", "nothing"));
-  EXPECT_EQ(Filter::FILTER_TYPE_UNSUPPORTED,
-            Filter::ConvertEncodingToType("strange", "nothing"));
-
-  // Check to see that apache bug (marking things as gzipped because of their
-  // on-disk file type) is ignored.
-  EXPECT_EQ(Filter::FILTER_TYPE_UNSUPPORTED,
-            Filter::ConvertEncodingToType("gzip", "application/x-gzip"));
-  EXPECT_EQ(Filter::FILTER_TYPE_UNSUPPORTED,
-            Filter::ConvertEncodingToType("gzip", "application/gzip"));
-  EXPECT_EQ(Filter::FILTER_TYPE_UNSUPPORTED,
-            Filter::ConvertEncodingToType("gzip", "application/x-gunzip"));
-
-  EXPECT_EQ(Filter::FILTER_TYPE_UNSUPPORTED,
-            Filter::ConvertEncodingToType("x-gzip", "application/x-gzip"));
-  EXPECT_EQ(Filter::FILTER_TYPE_UNSUPPORTED,
-            Filter::ConvertEncodingToType("x-gzip", "application/gzip"));
-  EXPECT_EQ(Filter::FILTER_TYPE_UNSUPPORTED,
-            Filter::ConvertEncodingToType("x-gzip", "application/x-gunzip"));
-}