Support new Safe Browsing list "goog-badresource-shavar" in SafeBrowsingDatabase.

chrome/browser/safe_browsing/local_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 <stddef.h>
 
 #include <string>
 #include <vector>
 
 #include "base/macros.h"
 #include "base/memory/ref_counted.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/run_loop.h"
 #include "chrome/browser/safe_browsing/local_database_manager.h"
+

[rkaplow, 2016/02/05 21:21:29]

unneeded?

[veranika, 2016/02/17 15:37:53]

Done.

 #include "chrome/browser/safe_browsing/safe_browsing_service.h"
 #include "content/public/test/test_browser_thread_bundle.h"
 #include "content/public/test/test_utils.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "testing/platform_test.h"
 #include "url/gurl.h"
 
 using content::TestBrowserThreadBundle;
 
 namespace safe_browsing {
@@ skipping 117 matching lines @@
 }
 
 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 kBlacklistedResourceUrl("http://www.blacklisted.com/script.js");
+  const GURL kUnwantedResourceUrl("http://www.unwantedresource.com/script.js");
+  const GURL kMalwareResourceUrl("http://www.malwareresource.com/script.js");
   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 kBlacklistedResourceHostHash =
+      SBFullHashForString("blacklisted.com/");
+  const SBFullHash kUnwantedResourceHostHash =
+      SBFullHashForString("unwantedresource.com/");
+  const SBFullHash kMalwareResourceHostHash =
+      SBFullHashForString("malwareresource.com/");
   const SBFullHash kSafeHostHash = SBFullHashForString("www.safe.com/");
 
   {
     SBFullHashResult full_hash;
     full_hash.hash = kMalwareHostHash;
     full_hash.list_id = static_cast<int>(MALWARE);
     full_hashes.push_back(full_hash);
   }
 
   {
     SBFullHashResult full_hash;
     full_hash.hash = kPhishingHostHash;
     full_hash.list_id = static_cast<int>(PHISH);
     full_hashes.push_back(full_hash);
   }
 
   {
     SBFullHashResult full_hash;
     full_hash.hash = kUnwantedHostHash;
     full_hash.list_id = static_cast<int>(UNWANTEDURL);
     full_hashes.push_back(full_hash);
   }
 
   {
+    SBFullHashResult full_hash;
+    full_hash.hash = kBlacklistedResourceHostHash;
+    full_hash.list_id = static_cast<int>(RESOURCEBLACKLIST);
+    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>(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>(UNWANTEDURL);
     full_hashes.push_back(full_hash_unwanted);
   }
 
+  {
+    SBFullHashResult full_hash_unwanted =
+        {kUnwantedResourceHostHash, static_cast<int>(UNWANTEDURL)};
+    full_hashes.push_back(full_hash_unwanted);
+
+    SBFullHashResult full_hash_resource =
+        {kUnwantedResourceHostHash, static_cast<int>(RESOURCEBLACKLIST)};
+    full_hashes.push_back(full_hash_resource);
+  }
+
+  {
+    SBFullHashResult full_hash_malware =
+        {kMalwareResourceHostHash, static_cast<int>(MALWARE)};
+    full_hashes.push_back(full_hash_malware);
+
+    SBFullHashResult full_hash_resource =
+        {kMalwareResourceHostHash, static_cast<int>(RESOURCEBLACKLIST)};
+    full_hashes.push_back(full_hash_resource);
+  }
+
   EXPECT_EQ(SB_THREAT_TYPE_URL_MALWARE,
             LocalSafeBrowsingDatabaseManager::GetHashSeverestThreatType(
                 kMalwareHostHash, full_hashes));
 
   EXPECT_EQ(SB_THREAT_TYPE_URL_PHISHING,
             LocalSafeBrowsingDatabaseManager::GetHashSeverestThreatType(
                 kPhishingHostHash, full_hashes));
 
   EXPECT_EQ(SB_THREAT_TYPE_URL_UNWANTED,
             LocalSafeBrowsingDatabaseManager::GetHashSeverestThreatType(
                 kUnwantedHostHash, full_hashes));
 
   EXPECT_EQ(SB_THREAT_TYPE_URL_MALWARE,
             LocalSafeBrowsingDatabaseManager::GetHashSeverestThreatType(
                 kUnwantedAndMalwareHostHash, full_hashes));
 
+  EXPECT_EQ(SB_THREAT_TYPE_BLACKLISTED_RESOURCE,
+            LocalSafeBrowsingDatabaseManager::GetHashSeverestThreatType(
+                kBlacklistedResourceHostHash, full_hashes));
+
+  EXPECT_EQ(SB_THREAT_TYPE_URL_UNWANTED,
+            LocalSafeBrowsingDatabaseManager::GetHashSeverestThreatType(
+                kUnwantedResourceHostHash, full_hashes));
+
+  EXPECT_EQ(SB_THREAT_TYPE_URL_MALWARE,
+            LocalSafeBrowsingDatabaseManager::GetHashSeverestThreatType(
+                kMalwareResourceHostHash, full_hashes));
+
   EXPECT_EQ(SB_THREAT_TYPE_SAFE,
             LocalSafeBrowsingDatabaseManager::GetHashSeverestThreatType(
                 kSafeHostHash, full_hashes));
 
   const size_t kArbitraryValue = 123456U;
   size_t index = kArbitraryValue;
   EXPECT_EQ(SB_THREAT_TYPE_URL_MALWARE,
             LocalSafeBrowsingDatabaseManager::GetUrlSeverestThreatType(
                 kMalwareUrl, full_hashes, &index));
   EXPECT_EQ(0U, index);
 
   EXPECT_EQ(SB_THREAT_TYPE_URL_PHISHING,
             LocalSafeBrowsingDatabaseManager::GetUrlSeverestThreatType(
                 kPhishingUrl, full_hashes, &index));
   EXPECT_EQ(1U, index);
 
   EXPECT_EQ(SB_THREAT_TYPE_URL_UNWANTED,
             LocalSafeBrowsingDatabaseManager::GetUrlSeverestThreatType(
                 kUnwantedUrl, full_hashes, &index));
   EXPECT_EQ(2U, index);
 
+  EXPECT_EQ(SB_THREAT_TYPE_BLACKLISTED_RESOURCE,
+            LocalSafeBrowsingDatabaseManager::GetUrlSeverestThreatType(
+                kBlacklistedResourceUrl, full_hashes, &index));
+  EXPECT_EQ(3U, index);
+
   EXPECT_EQ(SB_THREAT_TYPE_URL_MALWARE,
             LocalSafeBrowsingDatabaseManager::GetUrlSeverestThreatType(
                 kUnwantedAndMalwareUrl, full_hashes, &index));
-  EXPECT_EQ(3U, index);
+  EXPECT_EQ(4U, index);
+
+  EXPECT_EQ(SB_THREAT_TYPE_URL_UNWANTED,
+            LocalSafeBrowsingDatabaseManager::GetUrlSeverestThreatType(
+                kUnwantedResourceUrl, full_hashes, &index));
+  EXPECT_EQ(6U, index);
+
+  EXPECT_EQ(SB_THREAT_TYPE_URL_MALWARE,
+            LocalSafeBrowsingDatabaseManager::GetUrlSeverestThreatType(
+                kMalwareResourceUrl, full_hashes, &index));
+  EXPECT_EQ(8U, index);
 
   index = kArbitraryValue;
   EXPECT_EQ(SB_THREAT_TYPE_SAFE,
             LocalSafeBrowsingDatabaseManager::GetUrlSeverestThreatType(
                 kSafeUrl, full_hashes, &index));
   EXPECT_EQ(kArbitraryValue, index);
 }
 
 TEST_F(SafeBrowsingDatabaseManagerTest, ServiceStopWithPendingChecks) {
   scoped_refptr<SafeBrowsingService> sb_service(
@@ skipping 16 matching lines @@
   // Stop the service without first flushing above tasks.
   db_manager->StopOnIOThread(false);
 
   // Now run posted tasks, whish should include the extension check which has
   // been posted to the safe browsing task runner. This should not crash.
   content::RunAllBlockingPoolTasksUntilIdle();
   base::RunLoop().RunUntilIdle();
 }
 
 }  // namespace safe_browsing