Update from https://crrev.com/305340

net/filter/filter_unittest.cc

 // Copyright 2014 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/base/io_buffer.h"
 #include "net/filter/filter.h"
 #include "net/filter/mock_filter_context.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace net {
 
 namespace {
 
 class PassThroughFilter : public Filter {
  public:
   PassThroughFilter() : Filter(FILTER_TYPE_UNSUPPORTED) {}
 
   FilterStatus ReadFilteredData(char* dest_buffer, int* dest_len) override {
     return CopyOut(dest_buffer, dest_len);
   }
 
   DISALLOW_COPY_AND_ASSIGN(PassThroughFilter);
 };
 
 }  // namespace
 
-class FilterTest : public testing::Test {
-};
-
 TEST(FilterTest, ContentTypeId) {
   // Check for basic translation of Content-Encoding, including case variations.
   EXPECT_EQ(Filter::FILTER_TYPE_DEFLATE,
             Filter::ConvertEncodingToType("deflate"));
   EXPECT_EQ(Filter::FILTER_TYPE_DEFLATE,
             Filter::ConvertEncodingToType("deflAte"));
   EXPECT_EQ(Filter::FILTER_TYPE_GZIP,
             Filter::ConvertEncodingToType("gzip"));
   EXPECT_EQ(Filter::FILTER_TYPE_GZIP,
             Filter::ConvertEncodingToType("GzIp"));
   EXPECT_EQ(Filter::FILTER_TYPE_GZIP,
             Filter::ConvertEncodingToType("x-gzip"));
   EXPECT_EQ(Filter::FILTER_TYPE_GZIP,
             Filter::ConvertEncodingToType("X-GzIp"));
   EXPECT_EQ(Filter::FILTER_TYPE_SDCH,
             Filter::ConvertEncodingToType("sdch"));
   EXPECT_EQ(Filter::FILTER_TYPE_SDCH,
             Filter::ConvertEncodingToType("sDcH"));
   EXPECT_EQ(Filter::FILTER_TYPE_UNSUPPORTED,
             Filter::ConvertEncodingToType("weird"));
   EXPECT_EQ(Filter::FILTER_TYPE_UNSUPPORTED,
             Filter::ConvertEncodingToType("strange"));
 }
 
 // Check various fixups that modify content encoding lists.
 TEST(FilterTest, ApacheGzip) {
   MockFilterContext filter_context;
-  filter_context.SetSdchResponse(false);
+  filter_context.SetSdchResponse(NULL);
 
   // Check that redundant gzip mime type removes only solo gzip encoding.
   const std::string kGzipMime1("application/x-gzip");
   const std::string kGzipMime2("application/gzip");
   const std::string kGzipMime3("application/x-gunzip");
   std::vector<Filter::FilterType> encoding_types;
 
   // First show it removes the gzip, given any gzip style mime type.
   encoding_types.clear();
   encoding_types.push_back(Filter::FILTER_TYPE_GZIP);
@@ skipping 25 matching lines @@
   encoding_types.clear();
   encoding_types.push_back(Filter::FILTER_TYPE_GZIP);
   filter_context.SetMimeType("other/mime");
   Filter::FixupEncodingTypes(filter_context, &encoding_types);
   ASSERT_EQ(1U, encoding_types.size());
   EXPECT_EQ(Filter::FILTER_TYPE_GZIP, encoding_types.front());
 }
 
 TEST(FilterTest, GzipContentDispositionFilename) {
   MockFilterContext filter_context;
-  filter_context.SetSdchResponse(false);
+  filter_context.SetSdchResponse(NULL);
 
   const std::string kGzipMime("application/x-tar");
   const std::string kContentDisposition("attachment; filename=\"foo.tgz\"");
   const std::string kURL("http://foo.com/getfoo.php");
   std::vector<Filter::FilterType> encoding_types;
 
   encoding_types.push_back(Filter::FILTER_TYPE_GZIP);
   filter_context.SetMimeType(kGzipMime);
   filter_context.SetURL(GURL(kURL));
   filter_context.SetContentDisposition(kContentDisposition);
   Filter::FixupEncodingTypes(filter_context, &encoding_types);
   ASSERT_EQ(0U, encoding_types.size());
 }
 
 TEST(FilterTest, SdchEncoding) {
   // Handle content encodings including SDCH.
   const std::string kTextHtmlMime("text/html");
   MockFilterContext filter_context;
-  filter_context.SetSdchResponse(true);
+  // Empty handle indicates to filter that SDCH is active.
+  filter_context.SetSdchResponse(
+      SdchManager::CreateEmptyDictionarySetForTesting().Pass());
 
   std::vector<Filter::FilterType> encoding_types;
 
   // Check for most common encoding, and verify it survives unchanged.
   encoding_types.clear();
   encoding_types.push_back(Filter::FILTER_TYPE_SDCH);
   encoding_types.push_back(Filter::FILTER_TYPE_GZIP);
   filter_context.SetMimeType(kTextHtmlMime);
   Filter::FixupEncodingTypes(filter_context, &encoding_types);
   ASSERT_EQ(2U, encoding_types.size());
@@ skipping 16 matching lines @@
   Filter::FixupEncodingTypes(filter_context, &encoding_types);
   ASSERT_EQ(2U, encoding_types.size());
   EXPECT_EQ(Filter::FILTER_TYPE_SDCH, encoding_types[0]);
   EXPECT_EQ(Filter::FILTER_TYPE_GZIP_HELPING_SDCH, encoding_types[1]);
 }
 
 TEST(FilterTest, MissingSdchEncoding) {
   // Handle interesting case where entire SDCH encoding assertion "got lost."
   const std::string kTextHtmlMime("text/html");
   MockFilterContext filter_context;
-  filter_context.SetSdchResponse(true);
+  filter_context.SetSdchResponse(
+      SdchManager::CreateEmptyDictionarySetForTesting().Pass());
 
   std::vector<Filter::FilterType> encoding_types;
 
   // Loss of encoding, but it was an SDCH response with html type.
   encoding_types.clear();
   filter_context.SetMimeType(kTextHtmlMime);
   Filter::FixupEncodingTypes(filter_context, &encoding_types);
   ASSERT_EQ(2U, encoding_types.size());
   EXPECT_EQ(Filter::FILTER_TYPE_SDCH_POSSIBLE, encoding_types[0]);
   EXPECT_EQ(Filter::FILTER_TYPE_GZIP_HELPING_SDCH, encoding_types[1]);
 
   // Loss of encoding, but it was an SDCH response with a prefix that says it
-  // was an html type.  Note that it *should* be the case that a precise match
+  // was an html type. Note that it *should* be the case that a precise match
   // with "text/html" we be collected by GetMimeType() and passed in, but we
   // coded the fixup defensively (scanning for a prefix of "text/html", so this
   // is an example which could survive such confusion in the caller).
   encoding_types.clear();
   filter_context.SetMimeType("text/html; charset=UTF-8");
   Filter::FixupEncodingTypes(filter_context, &encoding_types);
   ASSERT_EQ(2U, encoding_types.size());
   EXPECT_EQ(Filter::FILTER_TYPE_SDCH_POSSIBLE, encoding_types[0]);
   EXPECT_EQ(Filter::FILTER_TYPE_GZIP_HELPING_SDCH, encoding_types[1]);
 
@@ skipping 255 matching lines @@
            amount_to_copy);
     filter1->FlushStreamBuffer(amount_to_copy);
     read_array_index += amount_to_copy;
   } while (true);
 
   EXPECT_EQ(read_array_index, input_array_size);
   EXPECT_EQ(compare_array_index, input_array_size);
 }
 
 }  // Namespace net