Sdch view for net-internals

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"
+#include "net/base/net_log.h"
 #include "net/base/sdch_manager.h"
 #include "net/base/sdch_observer.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "url/gurl.h"
 
 namespace net {
 
 //------------------------------------------------------------------------------
 // Provide sample data and compression results with a sample VCDIFF dictionary.
 // Note an SDCH dictionary has extra meta-data before the VCDIFF dictionary.
@@ skipping 45 matching lines @@
   // Reset globals back to default state.
   void TearDown() override {
     SdchManager::EnableSdchSupport(default_support_);
     SdchManager::EnableSecureSchemeSupport(default_https_support_);
   }
 
   // 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);
+    return sdch_manager_->AddSdchDictionary(dictionary_text, gurl) == SDCH_OK;
   }
 
  private:
   scoped_ptr<SdchManager> sdch_manager_;
   bool default_support_;
   bool default_https_support_;
 };
 
 static std::string NewSdchDictionary(const std::string& domain) {
   std::string dictionary;
   if (!domain.empty()) {
     dictionary.append("Domain: ");
     dictionary.append(domain);
     dictionary.append("\n");
   }
   dictionary.append("\n");
   dictionary.append(kTestVcdiffDictionary, sizeof(kTestVcdiffDictionary) - 1);
   return dictionary;
 }
 
 TEST_F(SdchManagerTest, DomainSupported) {
   GURL google_url("http://www.google.com");
 
   SdchManager::EnableSdchSupport(false);
-  EXPECT_FALSE(sdch_manager()->IsInSupportedDomain(google_url));
+  EXPECT_EQ(SDCH_DISABLED, sdch_manager()->IsInSupportedDomain(google_url));
   SdchManager::EnableSdchSupport(true);
-  EXPECT_TRUE(sdch_manager()->IsInSupportedDomain(google_url));
+  EXPECT_EQ(SDCH_OK, sdch_manager()->IsInSupportedDomain(google_url));
 }
 
 TEST_F(SdchManagerTest, DomainBlacklisting) {
   GURL test_url("http://www.test.com");
   GURL google_url("http://www.google.com");
 
-  sdch_manager()->BlacklistDomain(test_url, SdchManager::MIN_PROBLEM_CODE);
-  EXPECT_FALSE(sdch_manager()->IsInSupportedDomain(test_url));
-  EXPECT_TRUE(sdch_manager()->IsInSupportedDomain(google_url));
+  sdch_manager()->BlacklistDomain(test_url, SDCH_OK);
+  EXPECT_EQ(SDCH_DOMAIN_BLACKLIST_INCLUDES_TARGET,
+            sdch_manager()->IsInSupportedDomain(test_url));
+  EXPECT_EQ(SDCH_OK, sdch_manager()->IsInSupportedDomain(google_url));
 
-  sdch_manager()->BlacklistDomain(google_url, SdchManager::MIN_PROBLEM_CODE);
-  EXPECT_FALSE(sdch_manager()->IsInSupportedDomain(google_url));
+  sdch_manager()->BlacklistDomain(google_url, SDCH_OK);
+  EXPECT_EQ(SDCH_DOMAIN_BLACKLIST_INCLUDES_TARGET,
+            sdch_manager()->IsInSupportedDomain(google_url));
 }
 
 TEST_F(SdchManagerTest, DomainBlacklistingCaseSensitivity) {
   GURL test_url("http://www.TesT.com");
   GURL test2_url("http://www.tEst.com");
 
-  EXPECT_TRUE(sdch_manager()->IsInSupportedDomain(test_url));
-  EXPECT_TRUE(sdch_manager()->IsInSupportedDomain(test2_url));
-  sdch_manager()->BlacklistDomain(test_url, SdchManager::MIN_PROBLEM_CODE);
-  EXPECT_FALSE(sdch_manager()->IsInSupportedDomain(test2_url));
+  EXPECT_EQ(SDCH_OK, sdch_manager()->IsInSupportedDomain(test_url));
+  EXPECT_EQ(SDCH_OK, sdch_manager()->IsInSupportedDomain(test2_url));
+  sdch_manager()->BlacklistDomain(test_url, SDCH_OK);
+  EXPECT_EQ(SDCH_DOMAIN_BLACKLIST_INCLUDES_TARGET,
+            sdch_manager()->IsInSupportedDomain(test2_url));
 }
 
 TEST_F(SdchManagerTest, BlacklistingReset) {
   GURL gurl("http://mytest.DoMain.com");
   std::string domain(gurl.host());
 
   sdch_manager()->ClearBlacklistings();
   EXPECT_EQ(sdch_manager()->BlackListDomainCount(domain), 0);
   EXPECT_EQ(sdch_manager()->BlacklistDomainExponential(domain), 0);
-  EXPECT_TRUE(sdch_manager()->IsInSupportedDomain(gurl));
+  EXPECT_EQ(SDCH_OK, sdch_manager()->IsInSupportedDomain(gurl));
 }
 
 TEST_F(SdchManagerTest, BlacklistingSingleBlacklist) {
   GURL gurl("http://mytest.DoMain.com");
   std::string domain(gurl.host());
   sdch_manager()->ClearBlacklistings();
 
-  sdch_manager()->BlacklistDomain(gurl, SdchManager::MIN_PROBLEM_CODE);
+  sdch_manager()->BlacklistDomain(gurl, SDCH_OK);
   EXPECT_EQ(sdch_manager()->BlackListDomainCount(domain), 1);
   EXPECT_EQ(sdch_manager()->BlacklistDomainExponential(domain), 1);
 
   // Check that any domain lookup reduces the blacklist counter.
-  EXPECT_FALSE(sdch_manager()->IsInSupportedDomain(gurl));
+  EXPECT_EQ(SDCH_DOMAIN_BLACKLIST_INCLUDES_TARGET,
+            sdch_manager()->IsInSupportedDomain(gurl));
   EXPECT_EQ(sdch_manager()->BlackListDomainCount(domain), 0);
-  EXPECT_TRUE(sdch_manager()->IsInSupportedDomain(gurl));
+  EXPECT_EQ(SDCH_OK, sdch_manager()->IsInSupportedDomain(gurl));
 }
 
 TEST_F(SdchManagerTest, BlacklistingExponential) {
   GURL gurl("http://mytest.DoMain.com");
   std::string domain(gurl.host());
   sdch_manager()->ClearBlacklistings();
 
   int exponential = 1;
   for (int i = 1; i < 100; ++i) {
-    sdch_manager()->BlacklistDomain(gurl, SdchManager::MIN_PROBLEM_CODE);
+    sdch_manager()->BlacklistDomain(gurl, SDCH_OK);
     EXPECT_EQ(sdch_manager()->BlacklistDomainExponential(domain), exponential);
 
     EXPECT_EQ(sdch_manager()->BlackListDomainCount(domain), exponential);
-    EXPECT_FALSE(sdch_manager()->IsInSupportedDomain(gurl));
+    EXPECT_EQ(SDCH_DOMAIN_BLACKLIST_INCLUDES_TARGET,
+              sdch_manager()->IsInSupportedDomain(gurl));
     EXPECT_EQ(sdch_manager()->BlackListDomainCount(domain), exponential - 1);
 
     // Simulate a large number of domain checks (which eventually remove the
     // blacklisting).
     sdch_manager()->ClearDomainBlacklisting(domain);
     EXPECT_EQ(sdch_manager()->BlackListDomainCount(domain), 0);
-    EXPECT_TRUE(sdch_manager()->IsInSupportedDomain(gurl));
+    EXPECT_EQ(SDCH_OK, sdch_manager()->IsInSupportedDomain(gurl));
 
     // Predict what exponential backoff will be.
     exponential = 1 + 2 * exponential;
     if (exponential < 0)
       exponential = INT_MAX;  // We don't wrap.
   }
 }
 
 TEST_F(SdchManagerTest, CanSetExactMatchDictionary) {
   std::string dictionary_domain("x.y.z.google.com");
@@ skipping 50 matching lines @@
   // 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_EQ(SDCH_OK, 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(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_EQ(SDCH_DICTIONARY_FOUND_HAS_WRONG_SCHEME,
+            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(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_EQ(SDCH_DICTIONARY_FOUND_HAS_WRONG_SCHEME,
+            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(AddSdchDictionary(dictionary_text,
                                  GURL("http://y.z.google.com")));
@@ skipping 203 matching lines @@
   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(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_EQ(SDCH_OK, sdch_manager()->GetVcdiffDictionary(
+                         server_hash_1,
+                         GURL("http://" + dictionary_domain_1 + "/random_url"),
+                         &dictionary));
   EXPECT_TRUE(dictionary.get());
 
   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);
+  EXPECT_EQ(
+      SDCH_DICTIONARY_HASH_NOT_FOUND,
+      sdch_manager()->GetVcdiffDictionary(
+          server_hash_2, GURL("http://" + dictionary_domain_2 + "/random_url"),
+          &dictionary));
   EXPECT_FALSE(dictionary.get());
 
-  second_manager.GetVcdiffDictionary(
-      server_hash_1,
-      GURL("http://" + dictionary_domain_1 + "/random_url"),
-      &dictionary);
+  EXPECT_EQ(
+      SDCH_DICTIONARY_HASH_NOT_FOUND,
+      second_manager.GetVcdiffDictionary(
+          server_hash_1, GURL("http://" + dictionary_domain_1 + "/random_url"),
+          &dictionary));
   EXPECT_FALSE(dictionary.get());
 }
 
 TEST_F(SdchManagerTest, HttpsCorrectlySupported) {
   GURL url("http://www.google.com");
   GURL secure_url("https://www.google.com");
 
   bool expect_https_support = true;
 
-  EXPECT_TRUE(sdch_manager()->IsInSupportedDomain(url));
-  EXPECT_EQ(expect_https_support,
-            sdch_manager()->IsInSupportedDomain(secure_url));
+  SdchProblemCode expected_code =
+      expect_https_support ? SDCH_OK : SDCH_SECURE_SCHEME_NOT_SUPPORTED;
+
+  EXPECT_EQ(SDCH_OK, sdch_manager()->IsInSupportedDomain(url));
+  EXPECT_EQ(expected_code, sdch_manager()->IsInSupportedDomain(secure_url));
 
   SdchManager::EnableSecureSchemeSupport(!expect_https_support);
-  EXPECT_TRUE(sdch_manager()->IsInSupportedDomain(url));
-  EXPECT_NE(expect_https_support,
-            sdch_manager()->IsInSupportedDomain(secure_url));
+  EXPECT_EQ(SDCH_OK, sdch_manager()->IsInSupportedDomain(url));
+  EXPECT_NE(expected_code, sdch_manager()->IsInSupportedDomain(secure_url));
 }
 
 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(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_EQ(SDCH_OK, 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()->BlacklistDomain(GURL(blacklist_url), SDCH_OK);
+  EXPECT_EQ(SDCH_DOMAIN_BLACKLIST_INCLUDES_TARGET,
+            sdch_manager()->IsInSupportedDomain(blacklist_url));
 
   sdch_manager()->ClearData();
 
   dictionary = NULL;
-  sdch_manager()->GetVcdiffDictionary(
-      server_hash,
-      GURL("http://" + dictionary_domain + "/random_url"),
-      &dictionary);
+  EXPECT_EQ(
+      SDCH_DICTIONARY_HASH_NOT_FOUND,
+      sdch_manager()->GetVcdiffDictionary(
+          server_hash, GURL("http://" + dictionary_domain + "/random_url"),
+          &dictionary));
   EXPECT_FALSE(dictionary.get());
-  EXPECT_TRUE(sdch_manager()->IsInSupportedDomain(blacklist_url));
+  EXPECT_EQ(SDCH_OK, sdch_manager()->IsInSupportedDomain(blacklist_url));
 }
 
 TEST_F(SdchManagerTest, GetDictionaryNotification) {
   GURL test_request_gurl(GURL("http://www.example.com/data"));
   GURL test_dictionary_gurl(GURL("http://www.example.com/dict"));
   MockSdchObserver observer;
   sdch_manager()->AddObserver(&observer);
 
   EXPECT_EQ(0, observer.get_dictionary_notifications());
   sdch_manager()->OnGetDictionary(test_request_gurl, test_dictionary_gurl);
   EXPECT_EQ(1, observer.get_dictionary_notifications());
   EXPECT_EQ(test_request_gurl, observer.last_dictionary_request_url());
   EXPECT_EQ(test_dictionary_gurl, observer.last_dictionary_url());
 
   sdch_manager()->RemoveObserver(&observer);
   sdch_manager()->OnGetDictionary(test_request_gurl, test_dictionary_gurl);
   EXPECT_EQ(1, observer.get_dictionary_notifications());
   EXPECT_EQ(test_request_gurl, observer.last_dictionary_request_url());
   EXPECT_EQ(test_dictionary_gurl, observer.last_dictionary_url());
 }
 
 }  // namespace net