Change SDCHDictionaryFetcher to use URLRequest instead of URLFetcher.

net/base/sdch_manager_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 <string>
 
 #include "base/logging.h"
 #include "base/memory/scoped_ptr.h"
@@ skipping 17 matching lines @@
   }
 
   SdchManager* sdch_manager() { return sdch_manager_.get(); }
 
   // Reset globals back to default state.
   virtual void TearDown() {
     SdchManager::EnableSdchSupport(true);
     SdchManager::EnableSecureSchemeSupport(false);
   }
 
+  // Attempt to add a dictionary to the manager and probe for success or
+  // failure.
+  bool AddSdchDictionary(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.
+    return (list != list2);
+  }
+
  private:
   scoped_ptr<SdchManager> sdch_manager_;
 };
 
 //------------------------------------------------------------------------------
 static std::string NewSdchDictionary(const std::string& domain) {
   std::string dictionary;
   if (!domain.empty()) {
     dictionary.append("Domain: ");
     dictionary.append(domain);
@@ skipping 85 matching lines @@
     if (exponential < 0)
       exponential = INT_MAX;  // We don't wrap.
   }
 }
 
 TEST_F(SdchManagerTest, CanSetExactMatchDictionary) {
   std::string dictionary_domain("x.y.z.google.com");
   std::string dictionary_text(NewSdchDictionary(dictionary_domain));
 
   // Perfect match should work.
-  EXPECT_TRUE(sdch_manager()->AddSdchDictionary(dictionary_text,
-              GURL("http://" + dictionary_domain)));
+  EXPECT_TRUE(AddSdchDictionary(dictionary_text,
+                                GURL("http://" + dictionary_domain)));
 }
 
 TEST_F(SdchManagerTest, CanAdvertiseDictionaryOverHTTP) {
   std::string dictionary_domain("x.y.z.google.com");
   std::string dictionary_text(NewSdchDictionary(dictionary_domain));
 
-  EXPECT_TRUE(sdch_manager()->AddSdchDictionary(dictionary_text,
-              GURL("http://" + dictionary_domain)));
+  EXPECT_TRUE(AddSdchDictionary(dictionary_text,
+                                GURL("http://" + dictionary_domain)));
 
   std::string dictionary_list;
   // HTTP target URL can advertise dictionary.
   sdch_manager()->GetAvailDictionaryList(
       GURL("http://" + dictionary_domain + "/test"),
       &dictionary_list);
   EXPECT_FALSE(dictionary_list.empty());
 }
 
 TEST_F(SdchManagerTest, CanNotAdvertiseDictionaryOverHTTPS) {
   std::string dictionary_domain("x.y.z.google.com");
   std::string dictionary_text(NewSdchDictionary(dictionary_domain));
 
-  EXPECT_TRUE(sdch_manager()->AddSdchDictionary(dictionary_text,
-              GURL("http://" + dictionary_domain)));
+  EXPECT_TRUE(AddSdchDictionary(dictionary_text,
+                                GURL("http://" + dictionary_domain)));
 
   std::string dictionary_list;
   // HTTPS target URL should NOT advertise dictionary.
   sdch_manager()->GetAvailDictionaryList(
       GURL("https://" + dictionary_domain + "/test"),
       &dictionary_list);
   EXPECT_TRUE(dictionary_list.empty());
 }
 
 TEST_F(SdchManagerTest, CanUseHTTPSDictionaryOverHTTPSIfEnabled) {
   std::string dictionary_domain("x.y.z.google.com");
   std::string dictionary_text(NewSdchDictionary(dictionary_domain));
 
-  EXPECT_FALSE(sdch_manager()->AddSdchDictionary(
-      dictionary_text, GURL("https://" + dictionary_domain)));
+  EXPECT_FALSE(AddSdchDictionary(dictionary_text,
+                                 GURL("https://" + dictionary_domain)));
   SdchManager::EnableSecureSchemeSupport(true);
-  EXPECT_TRUE(sdch_manager()->AddSdchDictionary(
-      dictionary_text, GURL("https://" + dictionary_domain)));
+  EXPECT_TRUE(AddSdchDictionary(dictionary_text,
+                                GURL("https://" + dictionary_domain)));
 
   GURL target_url("https://" + dictionary_domain + "/test");
   std::string dictionary_list;
   // HTTPS target URL should advertise dictionary if secure scheme support is
   // enabled.
   sdch_manager()->GetAvailDictionaryList(target_url, &dictionary_list);
   EXPECT_FALSE(dictionary_list.empty());
 
   // Dictionary should be available.
   scoped_refptr<SdchManager::Dictionary> dictionary;
   std::string client_hash;
   std::string server_hash;
   sdch_manager()->GenerateHash(dictionary_text, &client_hash, &server_hash);
   sdch_manager()->GetVcdiffDictionary(server_hash, target_url, &dictionary);
   EXPECT_TRUE(dictionary.get() != NULL);
 }
 
 TEST_F(SdchManagerTest, CanNotUseHTTPDictionaryOverHTTPS) {
   std::string dictionary_domain("x.y.z.google.com");
   std::string dictionary_text(NewSdchDictionary(dictionary_domain));
 
-  EXPECT_TRUE(sdch_manager()->AddSdchDictionary(dictionary_text,
-              GURL("http://" + dictionary_domain)));
+  EXPECT_TRUE(AddSdchDictionary(dictionary_text,
+                                GURL("http://" + dictionary_domain)));
 
   GURL target_url("https://" + dictionary_domain + "/test");
   std::string dictionary_list;
   // HTTPS target URL should not advertise dictionary acquired over HTTP even if
   // secure scheme support is enabled.
   SdchManager::EnableSecureSchemeSupport(true);
   sdch_manager()->GetAvailDictionaryList(target_url, &dictionary_list);
   EXPECT_TRUE(dictionary_list.empty());
 
   scoped_refptr<SdchManager::Dictionary> dictionary;
   std::string client_hash;
   std::string server_hash;
   sdch_manager()->GenerateHash(dictionary_text, &client_hash, &server_hash);
   sdch_manager()->GetVcdiffDictionary(server_hash, target_url, &dictionary);
   EXPECT_TRUE(dictionary.get() == NULL);
 }
 
 TEST_F(SdchManagerTest, CanNotUseHTTPSDictionaryOverHTTP) {
   std::string dictionary_domain("x.y.z.google.com");
   std::string dictionary_text(NewSdchDictionary(dictionary_domain));
 
   SdchManager::EnableSecureSchemeSupport(true);
-  EXPECT_TRUE(sdch_manager()->AddSdchDictionary(dictionary_text,
-              GURL("https://" + dictionary_domain)));
+  EXPECT_TRUE(AddSdchDictionary(dictionary_text,
+                                GURL("https://" + dictionary_domain)));
 
   GURL target_url("http://" + dictionary_domain + "/test");
   std::string dictionary_list;
   // HTTP target URL should not advertise dictionary acquired over HTTPS even if
   // secure scheme support is enabled.
   sdch_manager()->GetAvailDictionaryList(target_url, &dictionary_list);
   EXPECT_TRUE(dictionary_list.empty());
 
   scoped_refptr<SdchManager::Dictionary> dictionary;
   std::string client_hash;
   std::string server_hash;
   sdch_manager()->GenerateHash(dictionary_text, &client_hash, &server_hash);
   sdch_manager()->GetVcdiffDictionary(server_hash, target_url, &dictionary);
   EXPECT_TRUE(dictionary.get() == NULL);
 }
 
 TEST_F(SdchManagerTest, FailToSetDomainMismatchDictionary) {
   std::string dictionary_domain("x.y.z.google.com");
   std::string dictionary_text(NewSdchDictionary(dictionary_domain));
 
   // Fail the "domain match" requirement.
-  EXPECT_FALSE(sdch_manager()->AddSdchDictionary(dictionary_text,
-               GURL("http://y.z.google.com")));
+  EXPECT_FALSE(AddSdchDictionary(dictionary_text,
+                                 GURL("http://y.z.google.com")));
 }
 
 TEST_F(SdchManagerTest, FailToSetDotHostPrefixDomainDictionary) {
   std::string dictionary_domain("x.y.z.google.com");
   std::string dictionary_text(NewSdchDictionary(dictionary_domain));
 
   // Fail the HD with D being the domain and H having a dot requirement.
-  EXPECT_FALSE(sdch_manager()->AddSdchDictionary(dictionary_text,
-               GURL("http://w.x.y.z.google.com")));
+  EXPECT_FALSE(AddSdchDictionary(dictionary_text,
+                                 GURL("http://w.x.y.z.google.com")));
 }
 
 TEST_F(SdchManagerTest, FailToSetRepeatPrefixWithDotDictionary) {
   // Make sure that a prefix that matches the domain postfix won't confuse
   // the validation checks.
   std::string dictionary_domain("www.google.com");
   std::string dictionary_text(NewSdchDictionary(dictionary_domain));
 
   // Fail the HD with D being the domain and H having a dot requirement.
-  EXPECT_FALSE(sdch_manager()->AddSdchDictionary(dictionary_text,
-               GURL("http://www.google.com.www.google.com")));
+  EXPECT_FALSE(AddSdchDictionary(dictionary_text,
+                                 GURL("http://www.google.com.www.google.com")));
 }
 
 TEST_F(SdchManagerTest, CanSetLeadingDotDomainDictionary) {
   // Make sure that a prefix that matches the domain postfix won't confuse
   // the validation checks.
   std::string dictionary_domain(".google.com");
   std::string dictionary_text(NewSdchDictionary(dictionary_domain));
 
   // Verify that a leading dot in the domain is acceptable, as long as the host
   // name does not contain any dots preceding the matched domain name.
-  EXPECT_TRUE(sdch_manager()->AddSdchDictionary(dictionary_text,
-               GURL("http://www.google.com")));
+  EXPECT_TRUE(AddSdchDictionary(dictionary_text, GURL("http://www.google.com")));
 }
 
 // Make sure the order of the tests is not helping us or confusing things.
 // See test CanSetExactMatchDictionary above for first try.
 TEST_F(SdchManagerTest, CanStillSetExactMatchDictionary) {
   std::string dictionary_domain("x.y.z.google.com");
   std::string dictionary_text(NewSdchDictionary(dictionary_domain));
 
   // Perfect match should *STILL* work.
-  EXPECT_TRUE(sdch_manager()->AddSdchDictionary(dictionary_text,
-              GURL("http://" + dictionary_domain)));
+  EXPECT_TRUE(AddSdchDictionary(dictionary_text,
+                                GURL("http://" + dictionary_domain)));
 }
 
 // Make sure the DOS protection precludes the addition of too many dictionaries.
 TEST_F(SdchManagerTest, TooManyDictionaries) {
   std::string dictionary_domain(".google.com");
   std::string dictionary_text(NewSdchDictionary(dictionary_domain));
 
-  size_t count = 0;
-  while (count <= SdchManager::kMaxDictionaryCount + 1) {
-    if (!sdch_manager()->AddSdchDictionary(dictionary_text,
-                                          GURL("http://www.google.com")))
-      break;
-
+  for (size_t count = 0; count < SdchManager::kMaxDictionaryCount; ++count) {
+    EXPECT_TRUE(AddSdchDictionary(dictionary_text,
+                                  GURL("http://www.google.com")));
     dictionary_text += " ";  // Create dictionary with different SHA signature.
-    ++count;
   }
-  EXPECT_EQ(SdchManager::kMaxDictionaryCount, count);
+  EXPECT_FALSE(
+      AddSdchDictionary(dictionary_text, GURL("http://www.google.com")));
 }
 
 TEST_F(SdchManagerTest, DictionaryNotTooLarge) {
   std::string dictionary_domain(".google.com");
   std::string dictionary_text(NewSdchDictionary(dictionary_domain));
 
   dictionary_text.append(
       SdchManager::kMaxDictionarySize  - dictionary_text.size(), ' ');
-  EXPECT_TRUE(sdch_manager()->AddSdchDictionary(dictionary_text,
-              GURL("http://" + dictionary_domain)));
+  EXPECT_TRUE(AddSdchDictionary(dictionary_text,
+                                GURL("http://" + dictionary_domain)));
 }
 
 TEST_F(SdchManagerTest, DictionaryTooLarge) {
   std::string dictionary_domain(".google.com");
   std::string dictionary_text(NewSdchDictionary(dictionary_domain));
 
   dictionary_text.append(
       SdchManager::kMaxDictionarySize + 1 - dictionary_text.size(), ' ');
-  EXPECT_FALSE(sdch_manager()->AddSdchDictionary(dictionary_text,
-              GURL("http://" + dictionary_domain)));
+  EXPECT_FALSE(AddSdchDictionary(dictionary_text,
+                                 GURL("http://" + dictionary_domain)));
 }
 
 TEST_F(SdchManagerTest, PathMatch) {
   bool (*PathMatch)(const std::string& path, const std::string& restriction) =
       SdchManager::Dictionary::PathMatch;
   // Perfect match is supported.
   EXPECT_TRUE(PathMatch("/search", "/search"));
   EXPECT_TRUE(PathMatch("/search/", "/search/"));
 
   // Prefix only works if last character of restriction is a slash, or first
@@ skipping 69 matching lines @@
 
   std::string tmp_hash;
   std::string server_hash_1;
   std::string server_hash_2;
 
   SdchManager::GenerateHash(dictionary_text_1, &tmp_hash, &server_hash_1);
   SdchManager::GenerateHash(dictionary_text_2, &tmp_hash, &server_hash_2);
 
   // Confirm that if you add directories to one manager, you
   // can't get them from the other.
-  EXPECT_TRUE(sdch_manager()->AddSdchDictionary(
-      dictionary_text_1, GURL("http://" + dictionary_domain_1)));
+  EXPECT_TRUE(AddSdchDictionary(dictionary_text_1,
+                                GURL("http://" + dictionary_domain_1)));
   scoped_refptr<SdchManager::Dictionary> dictionary;
   sdch_manager()->GetVcdiffDictionary(
       server_hash_1,
       GURL("http://" + dictionary_domain_1 + "/random_url"),
       &dictionary);
   EXPECT_TRUE(dictionary.get());
 
-  EXPECT_TRUE(second_manager.AddSdchDictionary(
-      dictionary_text_2, GURL("http://" + dictionary_domain_2)));
+  second_manager.AddSdchDictionary(
+      dictionary_text_2, GURL("http://" + dictionary_domain_2));
   second_manager.GetVcdiffDictionary(
       server_hash_2,
       GURL("http://" + dictionary_domain_2 + "/random_url"),
       &dictionary);
   EXPECT_TRUE(dictionary.get());
 
   sdch_manager()->GetVcdiffDictionary(
       server_hash_2,
       GURL("http://" + dictionary_domain_2 + "/random_url"),
       &dictionary);
@@ skipping 21 matching lines @@
 TEST_F(SdchManagerTest, ClearDictionaryData) {
   std::string dictionary_domain("x.y.z.google.com");
   GURL blacklist_url("http://bad.chromium.org");
 
   std::string dictionary_text(NewSdchDictionary(dictionary_domain));
   std::string tmp_hash;
   std::string server_hash;
 
   SdchManager::GenerateHash(dictionary_text, &tmp_hash, &server_hash);
 
-  EXPECT_TRUE(sdch_manager()->AddSdchDictionary(
-      dictionary_text, GURL("http://" + dictionary_domain)));
+  EXPECT_TRUE(AddSdchDictionary(dictionary_text,
+                                GURL("http://" + dictionary_domain)));
   scoped_refptr<SdchManager::Dictionary> dictionary;
   sdch_manager()->GetVcdiffDictionary(
       server_hash,
       GURL("http://" + dictionary_domain + "/random_url"),
       &dictionary);
   EXPECT_TRUE(dictionary.get());
 
   sdch_manager()->BlacklistDomain(GURL(blacklist_url),
                                   SdchManager::MIN_PROBLEM_CODE);
   EXPECT_FALSE(sdch_manager()->IsInSupportedDomain(blacklist_url));
 
   sdch_manager()->ClearData();
 
   dictionary = NULL;
   sdch_manager()->GetVcdiffDictionary(
       server_hash,
       GURL("http://" + dictionary_domain + "/random_url"),
       &dictionary);
   EXPECT_FALSE(dictionary.get());
   EXPECT_TRUE(sdch_manager()->IsInSupportedDomain(blacklist_url));
 }
 
 }  // namespace net