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 174 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,
+      obsolete_INCLUSION,

[Joe Mason, 2016/05/15 16:44:59]

Wasn't sure if it's safe to renumber this enum so I didn't remove this value.

[gab, 2016/05/16 13:27:58]

This enum is only used at runtime (not stored to disk or histogram) so it's safe
to remove this value.

Note: the only time it's not safe to remove a value and implicitly re-label
values following it is when it's used in histograms or stored to disk (in which
case best practice is to declare explicit values and leave it commented out for
reference on deprecation, e.g. as you did for ListType::INCLUSIONWHITELIST).

[Joe Mason, 2016/05/16 14:18:52]

Acknowledged. Couldn't tell from looking at the code whether it was serialized
or not.

       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_