Add the goog-unwanted-shavar list to a new SafeBrowsing PrefixSet.

chrome/browser/safe_browsing/database_manager_unittest.cc

 // Copyright 2013 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 <string>
 #include <vector>
 
 #include "base/memory/ref_counted.h"
 #include "base/memory/scoped_ptr.h"
 #include "chrome/browser/safe_browsing/database_manager.h"
@@ skipping 61 matching lines @@
   multiple_threats.push_back(SB_THREAT_TYPE_URL_MALWARE);
   multiple_threats.push_back(SB_THREAT_TYPE_URL_PHISHING);
   EXPECT_FALSE(RunSBHashTest(safe_browsing_util::MALWARE,
                              multiple_threats,
                              safe_browsing_util::kBinUrlList));
   EXPECT_TRUE(RunSBHashTest(safe_browsing_util::MALWARE,
                             multiple_threats,
                             safe_browsing_util::kMalwareList));
 }
 
-TEST_F(SafeBrowsingDatabaseManagerTest, GetUrlThreatType) {
+TEST_F(SafeBrowsingDatabaseManagerTest, GetUrlSeverestThreatType) {
   std::vector<SBFullHashResult> full_hashes;
 
   const GURL kMalwareUrl("http://www.malware.com/page.html");
   const GURL kPhishingUrl("http://www.phishing.com/page.html");
+  const GURL kUnwantedUrl("http://www.unwanted.com/page.html");
+  const GURL kUnwantedAndMalwareUrl(
+      "http://www.unwantedandmalware.com/page.html");
   const GURL kSafeUrl("http://www.safe.com/page.html");
 
   const SBFullHash kMalwareHostHash = SBFullHashForString("malware.com/");
   const SBFullHash kPhishingHostHash = SBFullHashForString("phishing.com/");
+  const SBFullHash kUnwantedHostHash = SBFullHashForString("unwanted.com/");
+  const SBFullHash kUnwantedAndMalwareHostHash =
+      SBFullHashForString("unwantedandmalware.com/");
   const SBFullHash kSafeHostHash = SBFullHashForString("www.safe.com/");
 
   {
     SBFullHashResult full_hash;
     full_hash.hash = kMalwareHostHash;
     full_hash.list_id = static_cast<int>(safe_browsing_util::MALWARE);
     full_hashes.push_back(full_hash);
   }
 
   {
     SBFullHashResult full_hash;
     full_hash.hash = kPhishingHostHash;
     full_hash.list_id = static_cast<int>(safe_browsing_util::PHISH);
     full_hashes.push_back(full_hash);
   }
 
+  {
+    SBFullHashResult full_hash;
+    full_hash.hash = kUnwantedHostHash;
+    full_hash.list_id = static_cast<int>(safe_browsing_util::UNWANTEDURL);
+    full_hashes.push_back(full_hash);
+  }
+
+  {
+    // Add both MALWARE and UNWANTEDURL list IDs for
+    // kUnwantedAndMalwareHostHash.
+    SBFullHashResult full_hash_malware;
+    full_hash_malware.hash = kUnwantedAndMalwareHostHash;
+    full_hash_malware.list_id = static_cast<int>(safe_browsing_util::MALWARE);
+    full_hashes.push_back(full_hash_malware);
+
+    SBFullHashResult full_hash_unwanted;
+    full_hash_unwanted.hash = kUnwantedAndMalwareHostHash;
+    full_hash_unwanted.list_id =
+        static_cast<int>(safe_browsing_util::UNWANTEDURL);
+    full_hashes.push_back(full_hash_unwanted);
+  }
+
   EXPECT_EQ(SB_THREAT_TYPE_URL_MALWARE,
-            SafeBrowsingDatabaseManager::GetHashThreatType(
+            SafeBrowsingDatabaseManager::GetHashSeverestThreatType(
                 kMalwareHostHash, full_hashes));
 
   EXPECT_EQ(SB_THREAT_TYPE_URL_PHISHING,
-            SafeBrowsingDatabaseManager::GetHashThreatType(
+            SafeBrowsingDatabaseManager::GetHashSeverestThreatType(
                 kPhishingHostHash, full_hashes));
 
+  EXPECT_EQ(SB_THREAT_TYPE_URL_UNWANTED,
+            SafeBrowsingDatabaseManager::GetHashSeverestThreatType(
+                kUnwantedHostHash, full_hashes));
+
+  EXPECT_EQ(SB_THREAT_TYPE_URL_MALWARE,
+            SafeBrowsingDatabaseManager::GetHashSeverestThreatType(
+                kUnwantedAndMalwareHostHash, full_hashes));
+
   EXPECT_EQ(SB_THREAT_TYPE_SAFE,
-            SafeBrowsingDatabaseManager::GetHashThreatType(
+            SafeBrowsingDatabaseManager::GetHashSeverestThreatType(
                 kSafeHostHash, full_hashes));
 
-  size_t index = 100;
+  const size_t kArbitraryValue = 123456U;
+  size_t index = kArbitraryValue;
   EXPECT_EQ(SB_THREAT_TYPE_URL_MALWARE,
-            SafeBrowsingDatabaseManager::GetUrlThreatType(
+            SafeBrowsingDatabaseManager::GetUrlSeverestThreatType(
                 kMalwareUrl, full_hashes, &index));
   EXPECT_EQ(0U, index);
 
   EXPECT_EQ(SB_THREAT_TYPE_URL_PHISHING,
-            SafeBrowsingDatabaseManager::GetUrlThreatType(
+            SafeBrowsingDatabaseManager::GetUrlSeverestThreatType(
                 kPhishingUrl, full_hashes, &index));
   EXPECT_EQ(1U, index);
 
-  index = 100;
+  EXPECT_EQ(SB_THREAT_TYPE_URL_UNWANTED,
+            SafeBrowsingDatabaseManager::GetUrlSeverestThreatType(
+                kUnwantedUrl, full_hashes, &index));
+  EXPECT_EQ(2U, index);
+
+  EXPECT_EQ(SB_THREAT_TYPE_URL_MALWARE,
+            SafeBrowsingDatabaseManager::GetUrlSeverestThreatType(
+                kUnwantedAndMalwareUrl, full_hashes, &index));
+  EXPECT_EQ(3U, index);
+
+  index = kArbitraryValue;
   EXPECT_EQ(SB_THREAT_TYPE_SAFE,
-            SafeBrowsingDatabaseManager::GetUrlThreatType(
+            SafeBrowsingDatabaseManager::GetUrlSeverestThreatType(
                 kSafeUrl, full_hashes, &index));
-  EXPECT_EQ(100U, index);
+  EXPECT_EQ(kArbitraryValue, index);
 }