Remove the unused OffDomainInclusionDetector

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 <memory>
 #include <set>
@@ skipping 140 matching lines @@
   // The download whitelist is used for two purposes: a white-domain list of
   // sites that are considered to host only harmless binaries as well as a
   // whitelist of arbitrary strings such as hashed certificate authorities that
   // are considered to be trusted.  The two methods below let you lookup the
   // whitelist either for a URL or an arbitrary string.  These methods will
   // return false if no match is found and true otherwise. This function is safe
   // to call from any thread.
   virtual bool ContainsDownloadWhitelistedUrl(const GURL& url) = 0;
   virtual bool ContainsDownloadWhitelistedString(const std::string& str) = 0;
 
-  // Returns true if |url| is on the off-domain inclusion whitelist.
-  virtual bool ContainsInclusionWhitelistedUrl(const GURL& url) = 0;
-
   // Returns true if the given module is on the module whitelist.
   virtual bool ContainsModuleWhitelistedString(const std::string& str) = 0;
 
   // Populates |prefix_hits| with any prefixes in |prefixes| that have matches
   // in the database, returning true if there were any matches.
   //
   // This function can ONLY be accessed from the creation thread.
   virtual bool ContainsExtensionPrefixes(
       const std::vector<SBPrefix>& prefixes,
       std::vector<SBPrefix>* prefix_hits) = 0;
@@ skipping 73 matching lines @@
       const base::FilePath& db_base_filename);
 
   // Filename for client-side phishing detection whitelist databsae.
   static base::FilePath CsdWhitelistDBFilename(
       const base::FilePath& csd_whitelist_base_filename);
 
   // Filename for download whitelist databsae.
   static base::FilePath DownloadWhitelistDBFilename(
       const base::FilePath& download_whitelist_base_filename);
 
-  // Filename for the off-domain inclusion whitelist databsae.
+  // Filename for the off-domain inclusion whitelist databsae.  This database no
+  // longer exists, but the filename is retained so the database may be deleted.
   static base::FilePath InclusionWhitelistDBFilename(
       const base::FilePath& inclusion_whitelist_base_filename);
 
   // Filename for extension blacklist database.
   static base::FilePath ExtensionBlacklistDBFilename(
       const base::FilePath& extension_blacklist_base_filename);
 
   // Filename for side-effect free whitelist database. This database no longer
   // exists, but the filename is retained so the database may be deleted.
   static base::FilePath SideEffectFreeWhitelistDBFilename(
@@ skipping 80 matching lines @@
  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* module_whitelist_store,
       SafeBrowsingStore* resource_blacklist_store);
 
   ~SafeBrowsingDatabaseNew() override;
 
   // Implement SafeBrowsingDatabase interface.
   void Init(const base::FilePath& filename) override;
@@ skipping 10 matching lines @@
       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 ContainsModuleWhitelistedString(const std::string& str) 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,
@@ skipping 41 matching lines @@
   // will automatically handle thread-safety.
   class ThreadSafeStateManager {
    public:
     // Identifiers for stores held by the ThreadSafeStateManager. Allows helper
     // methods to start a transaction themselves and keep it as short as
     // possible rather than force callers to start the transaction early to pass
     // a store pointer to the said helper methods.
     enum class SBWhitelistId {
       CSD,
       DOWNLOAD,
-      INCLUSION,
       MODULE,
     };
     enum class PrefixSetId {
       BROWSE,
       UNWANTED_SOFTWARE,
     };
 
     // Obtained through BeginReadTransaction(NoLockOnMainTaskRunner)?(): a
     // ReadTransaction allows read-only observations of the
     // ThreadSafeStateManager's state. The |prefix_gethash_cache_| has a special
@@ skipping 240 matching lines @@
   // Underlying persistent stores for chunk data:
   //   - |browse_store_|: For browsing related (phishing and malware URLs)
   //     chunks and prefixes.
   //   - |download_store_|: For download related (download URL and binary hash)
   //     chunks and prefixes.
   //   - |csd_whitelist_store_|: For the client-side phishing detection
   //     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).
   //   - |module_whitelist_store_|: For module whitelist. This list only
   //     contains 256 bit hashes.
   //   - |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
   // std::unique_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 std::unique_ptr<SafeBrowsingStore> browse_store_;
   const std::unique_ptr<SafeBrowsingStore> download_store_;
   const std::unique_ptr<SafeBrowsingStore> csd_whitelist_store_;
   const std::unique_ptr<SafeBrowsingStore> download_whitelist_store_;
-  const std::unique_ptr<SafeBrowsingStore> inclusion_whitelist_store_;
   const std::unique_ptr<SafeBrowsingStore> extension_blacklist_store_;
   const std::unique_ptr<SafeBrowsingStore> ip_blacklist_store_;
   const std::unique_ptr<SafeBrowsingStore> unwanted_software_store_;
   const std::unique_ptr<SafeBrowsingStore> module_whitelist_store_;
   const std::unique_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_