Change SDCHDictionaryFetcher to use URLRequest instead of URLFetcher.

net/filter/sdch_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 <limits.h>
 
 #include <algorithm>
 #include <string>
 #include <vector>
 
@@ skipping 45 matching lines @@
                               sizeof(kSdchCompressedTestData) - 1),
       expanded_(kTestData, sizeof(kTestData) - 1),
       sdch_manager_(new SdchManager),
       filter_context_(new MockFilterContext) {
     URLRequestContext* url_request_context =
         filter_context_->GetModifiableURLRequestContext();
 
     url_request_context->set_sdch_manager(sdch_manager_.get());
   }
 
+  // Attempt to add a dictionary to the manager and probe for success or
+  // failure.
+  void AddSdchDictionary(bool addition_should_succeed,
+                         const std::string& dictionary_text,
+                         const GURL& gurl) {
+    std::string list;
+    sdch_manager_->GetAvailDictionaryList(gurl, &list);
+    sdch_manager_->AddSdchDictionary(dictionary_text, gurl);
+    std::string list2;
+    sdch_manager_->GetAvailDictionaryList(gurl, &list2);
+    // The list of hashes should change iff the addition succeeds.
+    EXPECT_NE(addition_should_succeed, list == list2);
+  }
+
   MockFilterContext* filter_context() { return filter_context_.get(); }
 
-  std::string NewSdchCompressedData(const std::string dictionary);
+  std::string NewSdchCompressedData(const std::string dictionary) {
+    std::string client_hash;
+    std::string server_hash;
+    SdchManager::GenerateHash(dictionary, &client_hash, &server_hash);
+
+    // Build compressed data that refers to our dictionary.
+    std::string compressed(server_hash);
+    compressed.append("\0", 1);
+    compressed.append(vcdiff_compressed_data_);
+    return compressed;
+  }
 
   const std::string test_vcdiff_dictionary_;
   const std::string vcdiff_compressed_data_;
   const std::string expanded_;  // Desired final, decompressed data.
 
   scoped_ptr<SdchManager> sdch_manager_;
   scoped_ptr<MockFilterContext> filter_context_;
 };
 
-std::string SdchFilterTest::NewSdchCompressedData(
-    const std::string dictionary) {
-  std::string client_hash;
-  std::string server_hash;
-  SdchManager::GenerateHash(dictionary, &client_hash, &server_hash);
-
-  // Build compressed data that refers to our dictionary.
-  std::string compressed(server_hash);
-  compressed.append("\0", 1);
-  compressed.append(vcdiff_compressed_data_);
-  return compressed;
-}
-
 //------------------------------------------------------------------------------
 
 
 TEST_F(SdchFilterTest, Hashing) {
   std::string client_hash, server_hash;
   std::string dictionary("test contents");
   SdchManager::GenerateHash(dictionary, &client_hash, &server_hash);
 
   EXPECT_EQ(client_hash, "lMQBjS3P");
   EXPECT_EQ(server_hash, "MyciMVll");
@@ skipping 305 matching lines @@
   EXPECT_TRUE(sdch_manager_->IsInSupportedDomain(GURL(url_string)));
 }
 
 TEST_F(SdchFilterTest, DictionaryAddOnce) {
   // 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));
+  AddSdchDictionary(true, dictionary, url);
 
   // Check we can't add it twice.
-  EXPECT_FALSE(sdch_manager_->AddSdchDictionary(dictionary, url));
+  AddSdchDictionary(false, dictionary, url);
 
   const std::string kSampleDomain2 = "sdchtest2.com";
 
   // Don't test adding a second dictionary if our limits are tight.
   if (SdchManager::kMaxDictionaryCount > 1) {
     // Construct a second SDCH dictionary from a VCDIFF dictionary.
     std::string dictionary2(NewSdchDictionary(kSampleDomain2));
 
     std::string url_string2 = "http://" + kSampleDomain2;
     GURL url2(url_string2);
-    EXPECT_TRUE(sdch_manager_->AddSdchDictionary(dictionary2, url2));
+    AddSdchDictionary(true, dictionary2, url2);
   }
 }
 
 TEST_F(SdchFilterTest, BasicDictionary) {
   // 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));
+  AddSdchDictionary(true, dictionary, url);
 
   std::string compressed(NewSdchCompressedData(dictionary));
 
   std::vector<Filter::FilterType> filter_types;
   filter_types.push_back(Filter::FILTER_TYPE_SDCH);
 
   filter_context()->SetURL(url);
 
   scoped_ptr<Filter> filter(Filter::Factory(filter_types, *filter_context()));
 
@@ skipping 16 matching lines @@
 }
 
 TEST_F(SdchFilterTest, NoDecodeHttps) {
   // 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));
+  AddSdchDictionary(true, dictionary, url);
 
   std::string compressed(NewSdchCompressedData(dictionary));
 
   std::vector<Filter::FilterType> filter_types;
   filter_types.push_back(Filter::FILTER_TYPE_SDCH);
 
   filter_context()->SetURL(GURL("https://" + kSampleDomain));
   scoped_ptr<Filter> filter(Filter::Factory(filter_types, *filter_context()));
 
   const size_t feed_block_size(100);
   const size_t output_block_size(100);
   std::string output;
 
   EXPECT_FALSE(FilterTestData(compressed, feed_block_size, output_block_size,
                              filter.get(), &output));
 }
 
 // Current failsafe TODO/hack refuses to decode any content that doesn't use
 // http as the scheme (see use of DICTIONARY_SELECTED_FOR_NON_HTTP).
 // The following tests this blockage.  Note that blacklisting results, so we
 // we need separate tests for each of these.
 TEST_F(SdchFilterTest, NoDecodeFtp) {
   // 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));
+  AddSdchDictionary(true, dictionary, url);
 
   std::string compressed(NewSdchCompressedData(dictionary));
 
   std::vector<Filter::FilterType> filter_types;
   filter_types.push_back(Filter::FILTER_TYPE_SDCH);
 
   filter_context()->SetURL(GURL("ftp://" + kSampleDomain));
   scoped_ptr<Filter> filter(Filter::Factory(filter_types, *filter_context()));
 
   const size_t feed_block_size(100);
   const size_t output_block_size(100);
   std::string output;
 
   EXPECT_FALSE(FilterTestData(compressed, feed_block_size, output_block_size,
                              filter.get(), &output));
 }
 
 TEST_F(SdchFilterTest, NoDecodeFileColon) {
   // 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));
+  AddSdchDictionary(true, dictionary, url);
 
   std::string compressed(NewSdchCompressedData(dictionary));
 
   std::vector<Filter::FilterType> filter_types;
   filter_types.push_back(Filter::FILTER_TYPE_SDCH);
 
   filter_context()->SetURL(GURL("file://" + kSampleDomain));
   scoped_ptr<Filter> filter(Filter::Factory(filter_types, *filter_context()));
 
   const size_t feed_block_size(100);
   const size_t output_block_size(100);
   std::string output;
 
   EXPECT_FALSE(FilterTestData(compressed, feed_block_size, output_block_size,
                              filter.get(), &output));
 }
 
 TEST_F(SdchFilterTest, NoDecodeAboutColon) {
   // 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));
+  AddSdchDictionary(true, dictionary, url);
 
   std::string compressed(NewSdchCompressedData(dictionary));
 
   std::vector<Filter::FilterType> filter_types;
   filter_types.push_back(Filter::FILTER_TYPE_SDCH);
 
   filter_context()->SetURL(GURL("about://" + kSampleDomain));
   scoped_ptr<Filter> filter(Filter::Factory(filter_types, *filter_context()));
 
   const size_t feed_block_size(100);
   const size_t output_block_size(100);
   std::string output;
 
   EXPECT_FALSE(FilterTestData(compressed, feed_block_size, output_block_size,
                              filter.get(), &output));
 }
 
 TEST_F(SdchFilterTest, NoDecodeJavaScript) {
   // 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));
+  AddSdchDictionary(true, dictionary, url);
 
   std::string compressed(NewSdchCompressedData(dictionary));
 
   std::vector<Filter::FilterType> filter_types;
   filter_types.push_back(Filter::FILTER_TYPE_SDCH);
 
   filter_context()->SetURL(GURL("javascript://" + kSampleDomain));
   scoped_ptr<Filter> filter(Filter::Factory(filter_types, *filter_context()));
 
   const size_t feed_block_size(100);
   const size_t output_block_size(100);
   std::string output;
 
   EXPECT_FALSE(FilterTestData(compressed, feed_block_size, output_block_size,
                              filter.get(), &output));
 }
 
 TEST_F(SdchFilterTest, CanStillDecodeHttp) {
   // 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));
+  AddSdchDictionary(true, dictionary, url);
 
   std::string compressed(NewSdchCompressedData(dictionary));
 
   std::vector<Filter::FilterType> filter_types;
   filter_types.push_back(Filter::FILTER_TYPE_SDCH);
 
   filter_context()->SetURL(GURL("http://" + kSampleDomain));
   scoped_ptr<Filter> filter(Filter::Factory(filter_types, *filter_context()));
 
   const size_t feed_block_size(100);
   const size_t output_block_size(100);
   std::string output;
 
   EXPECT_TRUE(FilterTestData(compressed, feed_block_size, output_block_size,
                              filter.get(), &output));
 }
 
 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));
+  AddSdchDictionary(true, dictionary, url);
 
   std::string compressed(NewSdchCompressedData(dictionary));
 
   std::vector<Filter::FilterType> filter_types;
   filter_types.push_back(Filter::FILTER_TYPE_SDCH);
 
   // Decode with content arriving from the "wrong" domain.
   // This tests SdchManager::CanSet().
   GURL wrong_domain_url("http://www.wrongdomain.com");
   filter_context()->SetURL(wrong_domain_url);
@@ skipping 18 matching lines @@
   if (SdchManager::kMaxDictionaryCount <= 1)
     return;
 
   // 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));
+  AddSdchDictionary(true, 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));
+  AddSdchDictionary(true, dictionary_with_path, url);
 
   std::string compressed_for_path(NewSdchCompressedData(dictionary_with_path));
 
   std::vector<Filter::FilterType> filter_types;
   filter_types.push_back(Filter::FILTER_TYPE_SDCH);
 
   // Test decode the path data, arriving from a valid path.
   filter_context()->SetURL(GURL(url_string + path));
   scoped_ptr<Filter> filter(Filter::Factory(filter_types, *filter_context()));
 
@@ skipping 27 matching lines @@
   if (SdchManager::kMaxDictionaryCount <= 1)
     return;
 
   // 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));
+  AddSdchDictionary(true, dictionary, url);
 
 
   // 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)));
+  AddSdchDictionary(true, dictionary_with_port,
+                    GURL(url_string + ":" + port));
 
   std::string compressed_for_port(NewSdchCompressedData(dictionary_with_port));
 
   std::vector<Filter::FilterType> filter_types;
   filter_types.push_back(Filter::FILTER_TYPE_SDCH);
 
   // Test decode the port data, arriving from a valid port.
   filter_context()->SetURL(GURL(url_string + ":" + port));
   scoped_ptr<Filter> filter(Filter::Factory(filter_types, *filter_context()));
 
@@ skipping 100 matching lines @@
 // routinely followed by gzip (during encoding).  The filter we'll test for will
 // do the gzip decoding first, and then decode the SDCH content.
 TEST_F(SdchFilterTest, FilterChaining) {
   // 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));
+  AddSdchDictionary(true, 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<Filter::FilterType> filter_types;
   filter_types.push_back(Filter::FILTER_TYPE_SDCH);
   filter_types.push_back(Filter::FILTER_TYPE_GZIP);
@@ skipping 61 matching lines @@
 }
 
 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));
+  AddSdchDictionary(true, 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 use the gzipped sdch content.
   // System should automatically add the missing (optional) gzip.
   std::vector<Filter::FilterType> filter_types;
   filter_types.push_back(Filter::FILTER_TYPE_SDCH);
@@ skipping 35 matching lines @@
 }
 
 TEST_F(SdchFilterTest, AcceptGzipSdchIfGzip) {
   // 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));
+  AddSdchDictionary(true, 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);
 
   // Some proxies strip the content encoding statement down to a mere gzip, but
   // pass through the original content (with full sdch,gzip encoding).
   // Only claim to have gzip content, but really use the gzipped sdch content.
   // System should automatically add the missing (optional) sdch.
@@ skipping 38 matching lines @@
 }
 
 TEST_F(SdchFilterTest, DefaultSdchGzipIfEmpty) {
   // 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));
+  AddSdchDictionary(true, 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 non-encoded content, but really use the gzipped sdch
   // content.
   // System should automatically add the missing (optional) sdch,gzip.
   std::vector<Filter::FilterType> filter_types;
@@ skipping 35 matching lines @@
 }
 
 TEST_F(SdchFilterTest, AcceptGzipGzipSdchIfGzip) {
   // 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));
+  AddSdchDictionary(true, dictionary, url);
 
   std::string sdch_compressed(NewSdchCompressedData(dictionary));
 
   // Vodaphone (UK) Mobile Broadband provides double gzipped sdch with a content
   // encoding of merely gzip (apparently, only listing the extra level of
   // wrapper compression they added, but discarding the actual content encoding.
   // Use Gzip to double compress the sdch sdch_compressed data.
   std::string double_gzip_compressed_sdch = gzip_compress(gzip_compress(
       sdch_compressed));
 
@@ skipping 33 matching lines @@
 
   feed_block_size = 1;
   output_block_size = 1;
   output.clear();
   EXPECT_TRUE(FilterTestData(double_gzip_compressed_sdch, feed_block_size,
                              output_block_size, filter.get(), &output));
   EXPECT_EQ(output, expanded_);
 }
 
 }  // namespace net