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

chrome/browser/safe_browsing/safe_browsing_database.h

 // Copyright (c) 2011 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.
 
 #ifndef CHROME_BROWSER_SAFE_BROWSING_SAFE_BROWSING_DATABASE_H_
 #define CHROME_BROWSER_SAFE_BROWSING_SAFE_BROWSING_DATABASE_H_
 
 #include <map>
 #include <set>
 #include <string>
@@ skipping 24 matching lines @@
  public:
   SafeBrowsingDatabaseFactory() { }
   virtual ~SafeBrowsingDatabaseFactory() { }
   virtual 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 enable_unwanted_software_list) = 0;
+      bool enable_unwanted_software_list,
+      bool enable_resource_blacklists_list) = 0;
 
  private:
   DISALLOW_COPY_AND_ASSIGN(SafeBrowsingDatabaseFactory);
 };
 
 // Encapsulates on-disk databases that for safebrowsing. There are
 // four databases: browse, download, download whitelist and
 // client-side detection (csd) whitelist databases. The browse database contains
 // information about phishing and malware urls. The download database contains
 // URLs for bad binaries (e.g: those containing virus) and hash of
@@ skipping 10 matching lines @@
   // It is not thread safe.
   // The browse list and off-domain inclusion whitelist are always on;
   // availability of other lists is controlled by the flags on this method.
   static SafeBrowsingDatabase* Create(
       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 enable_unwanted_software_list);
+      bool enable_unwanted_software_list,
+      bool enable_resource_blacklist);

[Nathan Parker, 2016/02/16 21:42:00]

Do you need this?

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

Probably I don't. I added it here mostly to be uniform with similar lists.
Deleted.

 
   // Makes the passed |factory| the factory used to instantiate
   // a SafeBrowsingDatabase. This is used for tests.
   static void RegisterFactory(SafeBrowsingDatabaseFactory* factory) {
     factory_ = factory;
   }
 
   virtual ~SafeBrowsingDatabase();
 
   // Initializes the database with the given filename.
@@ skipping 76 matching lines @@
   //
   // This function can ONLY be accessed from the creation thread.
   virtual bool ContainsExtensionPrefixes(
       const std::vector<SBPrefix>& prefixes,
       std::vector<SBPrefix>* prefix_hits) = 0;
 
   // Returns true iff the given IP is currently on the csd malware IP blacklist.
   // This function is safe to call from any thread.
   virtual bool ContainsMalwareIP(const std::string& ip_address) = 0;
 
+  // Populates |prefix_hits| with any prefixes in |prefixes| that have matches
+  // in the database. Returns true iff there were any matches.
+  //
+  // This function can ONLY by accessed from the creation thread.
+  virtual bool ContainsResourceUrlPrefixes(
+      const std::vector<SBPrefix>& prefixes,
+      std::vector<SBPrefix>* prefix_hits) = 0;
+
   // A database transaction should look like:
   //
   // std::vector<SBListChunkRanges> lists;
   // if (db.UpdateStarted(&lists)) {
   //   // Do something with |lists|.
   //
   //   // Process add/sub commands.
   //   db.InsertChunks(list_name, chunks);
   //
   //   // Process adddel/subdel commands.
@@ skipping 71 matching lines @@
       const base::FilePath& side_effect_free_whitelist_base_filename);
 
   // Filename for the csd malware IP blacklist database.
   static base::FilePath IpBlacklistDBFilename(
       const base::FilePath& ip_blacklist_base_filename);
 
   // Filename for the unwanted software blacklist database.
   static base::FilePath UnwantedSoftwareDBFilename(
       const base::FilePath& db_filename);
 
+  static base::FilePath ResourceBlacklistDBFilename(
+      const base::FilePath& db_filename);
+
   // Get the prefixes matching the download |urls|.
   static void GetDownloadUrlPrefixes(const std::vector<GURL>& urls,
                                      std::vector<SBPrefix>* prefixes);
 
   // SafeBrowsing Database failure types for histogramming purposes.  Explicitly
   // label new values and do not re-use old values. Also make sure to reflect
   // modifications made below in the SB2DatabaseFailure histogram enum.
   enum FailureType {
     FAILURE_DATABASE_CORRUPT = 0,
     FAILURE_DATABASE_CORRUPT_HANDLER = 1,
@@ skipping 23 matching lines @@
     // Obsolete: FAILURE_SIDE_EFFECT_FREE_WHITELIST_PREFIX_SET_DELETE = 25,
     FAILURE_IP_BLACKLIST_UPDATE_BEGIN = 26,
     FAILURE_IP_BLACKLIST_UPDATE_FINISH = 27,
     FAILURE_IP_BLACKLIST_UPDATE_INVALID = 28,
     FAILURE_IP_BLACKLIST_DELETE = 29,
     FAILURE_UNWANTED_SOFTWARE_DATABASE_UPDATE_BEGIN = 30,
     FAILURE_UNWANTED_SOFTWARE_DATABASE_UPDATE_FINISH = 31,
     FAILURE_UNWANTED_SOFTWARE_PREFIX_SET_READ = 32,
     FAILURE_UNWANTED_SOFTWARE_PREFIX_SET_WRITE = 33,
     FAILURE_UNWANTED_SOFTWARE_PREFIX_SET_DELETE = 34,
+    FAILURE_RESOURCE_BLACKLIST_UPDATE_BEGIN = 35,
+    FAILURE_RESOURCE_BLACKLIST_UPDATE_FINISH = 36,
+    FAILURE_RESOURCE_BLACKLIST_DELETE = 37,
 
     // Memory space for histograms is determined by the max.  ALWAYS
     // ADD NEW VALUES BEFORE THIS ONE.
     FAILURE_DATABASE_MAX
   };
 
   static void RecordFailure(FailureType failure_type);
 
  private:
   // The factory used to instantiate a SafeBrowsingDatabase object.
   // Useful for tests, so they can provide their own implementation of
   // SafeBrowsingDatabase.
   static SafeBrowsingDatabaseFactory* factory_;
 };
 
 class SafeBrowsingDatabaseNew : public SafeBrowsingDatabase {
  public:
   // Create a database with the stores below. Takes ownership of all store
   // objects handed to this constructor. Ignores all future operations on lists
   // for which the store is initialized to NULL.
   SafeBrowsingDatabaseNew(
       const scoped_refptr<base::SequencedTaskRunner>& db_task_runner,
       SafeBrowsingStore* browse_store,
       SafeBrowsingStore* download_store,
       SafeBrowsingStore* csd_whitelist_store,
       SafeBrowsingStore* download_whitelist_store,
       SafeBrowsingStore* inclusion_whitelist_store,
       SafeBrowsingStore* extension_blacklist_store,
       SafeBrowsingStore* ip_blacklist_store,
-      SafeBrowsingStore* unwanted_software_store);
+      SafeBrowsingStore* unwanted_software_store,
+      SafeBrowsingStore* resource_blacklist_store);
 
   ~SafeBrowsingDatabaseNew() override;
 
   // Implement SafeBrowsingDatabase interface.
   void Init(const base::FilePath& filename) override;
   bool ResetDatabase() override;
   bool ContainsBrowseUrl(const GURL& url,
                          std::vector<SBPrefix>* prefix_hits,
                          std::vector<SBFullHashResult>* cache_hits) override;
   bool ContainsBrowseHashes(const std::vector<SBFullHash>& full_hashes,
                          std::vector<SBPrefix>* prefix_hits,
                          std::vector<SBFullHashResult>* cache_hits) override;
   bool ContainsUnwantedSoftwareUrl(
       const GURL& url,
       std::vector<SBPrefix>* prefix_hits,
       std::vector<SBFullHashResult>* cache_hits) override;
   bool ContainsUnwantedSoftwareHashes(
       const std::vector<SBFullHash>& full_hashes,
       std::vector<SBPrefix>* prefix_hits,
       std::vector<SBFullHashResult>* cache_hits) override;
   bool ContainsDownloadUrlPrefixes(const std::vector<SBPrefix>& prefixes,
                                    std::vector<SBPrefix>* prefix_hits) override;
   bool ContainsCsdWhitelistedUrl(const GURL& url) override;
   bool ContainsDownloadWhitelistedUrl(const GURL& url) override;
   bool ContainsDownloadWhitelistedString(const std::string& str) override;
   bool ContainsInclusionWhitelistedUrl(const GURL& url) override;
   bool ContainsExtensionPrefixes(const std::vector<SBPrefix>& prefixes,
                                  std::vector<SBPrefix>* prefix_hits) override;
   bool ContainsMalwareIP(const std::string& ip_address) override;
+  bool ContainsResourceUrlPrefixes(const std::vector<SBPrefix>& prefixes,
+                                   std::vector<SBPrefix>* prefix_hits) override;
+
   bool UpdateStarted(std::vector<SBListChunkRanges>* lists) override;
   void InsertChunks(
       const std::string& list_name,
       const std::vector<scoped_ptr<SBChunkData>>& chunks) override;
   void DeleteChunks(const std::vector<SBChunkDelete>& chunk_deletes) override;
   void UpdateFinished(bool update_succeeded) override;
   void CacheHashResults(const std::vector<SBPrefix>& prefixes,
                         const std::vector<SBFullHashResult>& full_hits,
                         const base::TimeDelta& cache_lifetime) override;
 
@@ skipping 298 matching lines @@
   //     whitelist chunks and full-length hashes.  This list only contains 256
   //     bit hashes.
   //   - |download_whitelist_store_|: For the download whitelist chunks and
   //     full-length hashes.  This list only contains 256 bit hashes.
   //   - |inclusion_whitelist_store_|: For the inclusion whitelist. Same format
   //     as |download_whitelist_store_|.
   //   - |extension_blacklist_store_|: For extension IDs.
   //   - |ip_blacklist_store_|: For IP blacklist.
   //   - |unwanted_software_store_|: For unwanted software list (format
   //     identical to browsing lists).
+  //   - |resource_blacklist_store_|: For script resource list (format identical
+  //     to browsing lists).
   //
   // The stores themselves will be modified throughout the existence of this
   // database, but shouldn't ever be swapped out (hence the const scoped_ptr --
   // which could be swapped for C++11's std::optional when that's available).
   // They are NonThreadSafe and should thus only be accessed on the database's
   // main thread as enforced by SafeBrowsingStoreFile's implementation.
   const scoped_ptr<SafeBrowsingStore> browse_store_;
   const scoped_ptr<SafeBrowsingStore> download_store_;
   const scoped_ptr<SafeBrowsingStore> csd_whitelist_store_;
   const scoped_ptr<SafeBrowsingStore> download_whitelist_store_;
   const scoped_ptr<SafeBrowsingStore> inclusion_whitelist_store_;
   const scoped_ptr<SafeBrowsingStore> extension_blacklist_store_;
   const scoped_ptr<SafeBrowsingStore> ip_blacklist_store_;
   const scoped_ptr<SafeBrowsingStore> unwanted_software_store_;
+  const scoped_ptr<SafeBrowsingStore> resource_blacklist_store_;
 
   // Used to schedule resetting the database because of corruption. This factory
   // and the WeakPtrs it issues should only be used on the database's main
   // thread.
   base::WeakPtrFactory<SafeBrowsingDatabaseNew> reset_factory_;
 };
 
 }  // namespace safe_browsing
 
 #endif  // CHROME_BROWSER_SAFE_BROWSING_SAFE_BROWSING_DATABASE_H_