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

chrome/browser/safe_browsing/safe_browsing_service_browsertest.cc

 // Copyright (c) 2012 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.
 //
 // This test creates a safebrowsing service using test safebrowsing database
 // and a test protocol manager. It is used to test logics in safebrowsing
 // service.
 
 #include "chrome/browser/safe_browsing/safe_browsing_service.h"
 
@@ skipping 242 matching lines @@
   bool ContainsInclusionWhitelistedUrl(const GURL& url) override {
     return true;
   }
   bool ContainsExtensionPrefixes(const std::vector<SBPrefix>& prefixes,
                                  std::vector<SBPrefix>* prefix_hits) override {
     return false;
   }
   bool ContainsMalwareIP(const std::string& ip_address) override {
     return true;
   }
+  bool ContainsResourceUrlPrefixes(
+      const std::vector<SBPrefix>& prefixes,
+      std::vector<SBPrefix>* prefix_hits) override {
+    prefix_hits->clear();
+    return ContainsUrlPrefixes(RESOURCEBLACKLIST, RESOURCEBLACKLIST,
+                               prefixes, prefix_hits);
+  }
   bool UpdateStarted(std::vector<SBListChunkRanges>* lists) override {
     ADD_FAILURE() << "Not implemented.";
     return false;
   }
   void InsertChunks(
       const std::string& list_name,
       const std::vector<scoped_ptr<SBChunkData>>& chunks) override {
     ADD_FAILURE() << "Not implemented.";
   }
   void DeleteChunks(const std::vector<SBChunkDelete>& chunk_deletes) override {
@@ skipping 97 matching lines @@
   TestSafeBrowsingDatabaseFactory() : db_(NULL) {}
   ~TestSafeBrowsingDatabaseFactory() override {}
 
   SafeBrowsingDatabase* CreateSafeBrowsingDatabase(
       const scoped_refptr<base::SequencedTaskRunner>& db_task_runner,
       bool enable_download_protection,
       bool enable_client_side_whitelist,
       bool enable_download_whitelist,
       bool enable_extension_blacklist,
       bool enable_ip_blacklist,
-      bool enabled_unwanted_software_list) override {
+      bool enabled_unwanted_software_list,
+      bool enable_resource_blacklist) override {
     db_ = new TestSafeBrowsingDatabase();
     return db_;
   }
   TestSafeBrowsingDatabase* GetDb() { return db_; }
 
  private:
   // Owned by the SafebrowsingService.
   TestSafeBrowsingDatabase* db_;
 };
 
@@ skipping 739 matching lines @@
 
 class TestSBClient : public base::RefCountedThreadSafe<TestSBClient>,
                      public SafeBrowsingDatabaseManager::Client {
  public:
   TestSBClient()
       : threat_type_(SB_THREAT_TYPE_SAFE),
         safe_browsing_service_(g_browser_process->safe_browsing_service()) {}
 
   SBThreatType GetThreatType() const { return threat_type_; }
 
+  std::string GetThreatHash() const { return threat_hash_; }
+
   void CheckDownloadUrl(const std::vector<GURL>& url_chain) {
     BrowserThread::PostTask(
         BrowserThread::IO, FROM_HERE,
         base::Bind(&TestSBClient::CheckDownloadUrlOnIOThread, this, url_chain));
     content::RunMessageLoop();  // Will stop in OnCheckDownloadUrlResult.
   }
 
   void CheckBrowseUrl(const GURL& url) {
     BrowserThread::PostTask(
         BrowserThread::IO, FROM_HERE,
         base::Bind(&TestSBClient::CheckBrowseUrlOnIOThread, this, url));
     content::RunMessageLoop();  // Will stop in OnCheckBrowseUrlResult.
   }
 
+  void CheckResourceUrl(const GURL& url) {
+    BrowserThread::PostTask(
+        BrowserThread::IO, FROM_HERE,
+        base::Bind(&TestSBClient::CheckResourceUrlOnIOThread, this, url));
+    content::RunMessageLoop();  // Will stop in OnCheckResourceUrlResult.
+  }
+
  private:
   friend class base::RefCountedThreadSafe<TestSBClient>;
   ~TestSBClient() override {}
 
   void CheckDownloadUrlOnIOThread(const std::vector<GURL>& url_chain) {
     bool synchronous_safe_signal =
         safe_browsing_service_->database_manager()->CheckDownloadUrl(url_chain,
                                                                      this);
     if (synchronous_safe_signal) {
       threat_type_ = SB_THREAT_TYPE_SAFE;
       BrowserThread::PostTask(BrowserThread::UI, FROM_HERE,
                               base::Bind(&TestSBClient::CheckDone, this));
     }
   }
 
   void CheckBrowseUrlOnIOThread(const GURL& url) {
     // The async CheckDone() hook will not be called when we have a synchronous
     // safe signal, handle it right away.
     bool synchronous_safe_signal =
         safe_browsing_service_->database_manager()->CheckBrowseUrl(url, this);
     if (synchronous_safe_signal) {
       threat_type_ = SB_THREAT_TYPE_SAFE;
       BrowserThread::PostTask(BrowserThread::UI, FROM_HERE,
                               base::Bind(&TestSBClient::CheckDone, this));
     }
   }
 
+  void CheckResourceUrlOnIOThread(const GURL& url) {
+    bool synchronous_safe_signal =
+        safe_browsing_service_->database_manager()->CheckResourceUrl(url, this);
+    if (synchronous_safe_signal) {
+      threat_type_ = SB_THREAT_TYPE_SAFE;
+      BrowserThread::PostTask(BrowserThread::UI, FROM_HERE,
+                              base::Bind(&TestSBClient::CheckDone, this));
+    }
+  }
+
   // Called when the result of checking a download URL is known.
   void OnCheckDownloadUrlResult(const std::vector<GURL>& /* url_chain */,
                                 SBThreatType threat_type) override {
     threat_type_ = threat_type;
     BrowserThread::PostTask(BrowserThread::UI, FROM_HERE,
                             base::Bind(&TestSBClient::CheckDone, this));
   }
 
   // Called when the result of checking a browse URL is known.
   void OnCheckBrowseUrlResult(const GURL& /* url */,
                               SBThreatType threat_type,
                               const std::string& /* metadata */) override {
     threat_type_ = threat_type;
     BrowserThread::PostTask(BrowserThread::UI, FROM_HERE,
                             base::Bind(&TestSBClient::CheckDone, this));
   }
 
+  // Called when the result of checking a resource URL is known.
+  void OnCheckResourceUrlResult(const GURL& /* url */,
+                                SBThreatType threat_type,
+                                const std::string& threat_hash) override {
+    threat_type_ = threat_type;
+    threat_hash_ = threat_hash;
+    BrowserThread::PostTask(BrowserThread::UI, FROM_HERE,
+                            base::Bind(&TestSBClient::CheckDone, this));
+  }
+
   void CheckDone() { base::MessageLoopForUI::current()->QuitWhenIdle(); }
 
   SBThreatType threat_type_;
+  std::string threat_hash_;
   SafeBrowsingService* safe_browsing_service_;
 
   DISALLOW_COPY_AND_ASSIGN(TestSBClient);
 };
 
 }  // namespace
 
 // These tests use SafeBrowsingService::Client to directly interact with
 // SafeBrowsingService.
 IN_PROC_BROWSER_TEST_F(SafeBrowsingServiceTest, CheckDownloadUrl) {
@@ skipping 115 matching lines @@
   SBFullHashResult full_hash_result;
   GenUrlFullhashResult(badbin_url, BINURL, &full_hash_result);
   SetupResponseForUrl(badbin_url, full_hash_result);
 
   client->CheckDownloadUrl(badbin_urls);
 
   // Now, the badbin_url is not safe since it is added to download database.
   EXPECT_EQ(SB_THREAT_TYPE_BINARY_MALWARE_URL, client->GetThreatType());
 }
 
+IN_PROC_BROWSER_TEST_F(SafeBrowsingServiceTest, CheckResourceUrl) {
+  const char* kBlacklistResource = "/blacklisted/script.js";
+  GURL blacklist_resource = embedded_test_server()->GetURL(kBlacklistResource);
+  std::string blacklist_resource_hash;
+  const char* kMaliciousResource = "/malware/script.js";
+  GURL malware_resource = embedded_test_server()->GetURL(kMaliciousResource);
+  std::string malware_resource_hash;
+
+  {
+    SBFullHashResult full_hash;
+    GenUrlFullhashResult(blacklist_resource, RESOURCEBLACKLIST, &full_hash);
+    SetupResponseForUrl(blacklist_resource, full_hash);
+    blacklist_resource_hash = std::string(full_hash.hash.full_hash,
+                                          full_hash.hash.full_hash + 32);
+  }
+  {
+    SBFullHashResult full_hash;
+    GenUrlFullhashResult(malware_resource, MALWARE, &full_hash);
+    SetupResponseForUrl(malware_resource, full_hash);
+    full_hash.list_id = RESOURCEBLACKLIST;
+    SetupResponseForUrl(malware_resource, full_hash);
+    malware_resource_hash = std::string(full_hash.hash.full_hash,
+                                        full_hash.hash.full_hash + 32);
+  }
+
+  scoped_refptr<TestSBClient> client(new TestSBClient);
+  client->CheckResourceUrl(blacklist_resource);
+  EXPECT_EQ(SB_THREAT_TYPE_BLACKLISTED_RESOURCE, client->GetThreatType());
+  EXPECT_EQ(blacklist_resource_hash, client->GetThreatHash());
+
+  // Since we're checking a resource url, we should receive result that it's
+  // a blacklisted resource, not a malware.
+  client = new TestSBClient;
+  client->CheckResourceUrl(malware_resource);
+  EXPECT_EQ(SB_THREAT_TYPE_BLACKLISTED_RESOURCE, client->GetThreatType());
+  EXPECT_EQ(malware_resource_hash, client->GetThreatHash());
+
+  client->CheckResourceUrl(embedded_test_server()->GetURL(kEmptyPage));
+  EXPECT_EQ(SB_THREAT_TYPE_SAFE, client->GetThreatType());
+}
+
 #if defined(OS_WIN)
 // http://crbug.com/396409
 #define MAYBE_CheckDownloadUrlTimedOut DISABLED_CheckDownloadUrlTimedOut
 #else
 #define MAYBE_CheckDownloadUrlTimedOut CheckDownloadUrlTimedOut
 #endif
 IN_PROC_BROWSER_TEST_F(SafeBrowsingServiceTest,
                        MAYBE_CheckDownloadUrlTimedOut) {
   GURL badbin_url = embedded_test_server()->GetURL(kMalwareFile);
   std::vector<GURL> badbin_urls(1, badbin_url);
@@ skipping 321 matching lines @@
       chrome::NOTIFICATION_SAFE_BROWSING_UPDATE_COMPLETE,
       content::Source<SafeBrowsingDatabaseManager>(
           sb_service_->database_manager().get()));
   BrowserThread::PostTask(
       BrowserThread::IO, FROM_HERE,
       base::Bind(&SafeBrowsingDatabaseManagerCookieTest::ForceUpdate, this));
   observer.Wait();
 }
 
 }  // namespace safe_browsing