Remove PrerenderLocalPredictor, part 2.

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 21 matching lines @@
 class SafeBrowsingDatabaseFactory {
  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_side_effect_free_whitelist,
       bool enable_ip_blacklist,
       bool enable_unwanted_software_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
@@ skipping 11 matching lines @@
   // Factory method for obtaining a SafeBrowsingDatabase implementation.
   // 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 side_effect_free_whitelist,
       bool enable_ip_blacklist,
       bool enable_unwanted_software_list);
 
   // 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();
@@ skipping 52 matching lines @@
   virtual bool ContainsInclusionWhitelistedUrl(const GURL& url) = 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;
 
-  // Returns false unless the hash of |url| is on the side-effect free
-  // whitelist. This function is safe to call from any thread.
-  virtual bool ContainsSideEffectFreeWhitelistUrl(const GURL& url) = 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;
 
   // A database transaction should look like:
   //
   // std::vector<SBListChunkRanges> lists;
   // if (db.UpdateStarted(&lists)) {
   //   // Do something with |lists|.
   //
@@ skipping 61 matching lines @@
       const base::FilePath& download_whitelist_base_filename);
 
   // Filename for the off-domain inclusion whitelist databsae.
   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.
+  // 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(
       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);
@@ skipping 19 matching lines @@
     FAILURE_DOWNLOAD_DATABASE_UPDATE_BEGIN = 10,
     FAILURE_DOWNLOAD_DATABASE_UPDATE_FINISH = 11,
     FAILURE_WHITELIST_DATABASE_UPDATE_BEGIN = 12,
     FAILURE_WHITELIST_DATABASE_UPDATE_FINISH = 13,
     FAILURE_BROWSE_PREFIX_SET_READ = 14,
     FAILURE_BROWSE_PREFIX_SET_WRITE = 15,
     FAILURE_BROWSE_PREFIX_SET_DELETE = 16,
     FAILURE_EXTENSION_BLACKLIST_UPDATE_BEGIN = 17,
     FAILURE_EXTENSION_BLACKLIST_UPDATE_FINISH = 18,
     FAILURE_EXTENSION_BLACKLIST_DELETE = 19,
-    FAILURE_SIDE_EFFECT_FREE_WHITELIST_UPDATE_BEGIN = 20,
-    FAILURE_SIDE_EFFECT_FREE_WHITELIST_UPDATE_FINISH = 21,
-    FAILURE_SIDE_EFFECT_FREE_WHITELIST_DELETE = 22,
-    FAILURE_SIDE_EFFECT_FREE_WHITELIST_PREFIX_SET_READ = 23,
-    FAILURE_SIDE_EFFECT_FREE_WHITELIST_PREFIX_SET_WRITE = 24,
-    FAILURE_SIDE_EFFECT_FREE_WHITELIST_PREFIX_SET_DELETE = 25,
+    // Obsolete: FAILURE_SIDE_EFFECT_FREE_WHITELIST_UPDATE_BEGIN = 20,
+    // Obsolete: FAILURE_SIDE_EFFECT_FREE_WHITELIST_UPDATE_FINISH = 21,
+    // Obsolete: FAILURE_SIDE_EFFECT_FREE_WHITELIST_DELETE = 22,
+    // Obsolete: FAILURE_SIDE_EFFECT_FREE_WHITELIST_PREFIX_SET_READ = 23,
+    // Obsolete: FAILURE_SIDE_EFFECT_FREE_WHITELIST_PREFIX_SET_WRITE = 24,
+    // 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,
 
@@ skipping 17 matching lines @@
   // 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* side_effect_free_whitelist_store,
       SafeBrowsingStore* ip_blacklist_store,
       SafeBrowsingStore* unwanted_software_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 ContainsUnwantedSoftwareUrl(
       const GURL& url,
       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 ContainsSideEffectFreeWhitelistUrl(const GURL& url) override;
   bool ContainsMalwareIP(const std::string& ip_address) override;
   bool UpdateStarted(std::vector<SBListChunkRanges>* lists) override;
   void InsertChunks(const std::string& list_name,
                     const std::vector<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 38 matching lines @@
     // 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,
     };
     enum class PrefixSetId {
       BROWSE,
-      SIDE_EFFECT_FREE_WHITELIST,
       UNWANTED_SOFTWARE,
     };
 
     // Obtained through BeginReadTransaction(NoLockOnMainTaskRunner)?(): a
     // ReadTransaction allows read-only observations of the
     // ThreadSafeStateManager's state. The |prefix_gethash_cache_| has a special
     // allowance to be writable from a ReadTransaction but can't benefit from
     // unlocked ReadTransactions. ReadTransaction should be held for the
     // shortest amount of time possible (e.g., release it before computing final
     // results if possible).
@@ skipping 25 matching lines @@
     SBWhitelist download_whitelist_;
     SBWhitelist inclusion_whitelist_;
 
     // The IP blacklist should be small.  At most a couple hundred IPs.
     IPBlacklist ip_blacklist_;
 
     // PrefixSets to speed up lookups for particularly large lists. The
     // PrefixSet themselves are never modified, instead a new one is swapped in
     // on update.
     scoped_ptr<const safe_browsing::PrefixSet> browse_prefix_set_;
-    scoped_ptr<const safe_browsing::PrefixSet>
-        side_effect_free_whitelist_prefix_set_;
     scoped_ptr<const safe_browsing::PrefixSet> unwanted_software_prefix_set_;
 
     // Cache of gethash results for prefix stores. Entries should not be used if
     // they are older than their expire_after field.  Cached misses will have
     // empty full_hashes field.  Cleared on each update. The cache is "mutable"
     // as it can be written to from any transaction holding the lock, including
     // ReadTransactions.
     mutable PrefixGetHashCache prefix_gethash_cache_;
 
     DISALLOW_COPY_AND_ASSIGN(ThreadSafeStateManager);
@@ skipping 199 matching lines @@
   //   - |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.
-  //   - |side_effect_free_whitelist_store_|: For side-effect free whitelist.
   //   - |ip_blacklist_store_|: For IP blacklist.
   //   - |unwanted_software_store_|: For unwanted software 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> side_effect_free_whitelist_store_;
   const scoped_ptr<SafeBrowsingStore> ip_blacklist_store_;
   const scoped_ptr<SafeBrowsingStore> unwanted_software_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_;
 };
 
 #endif  // CHROME_BROWSER_SAFE_BROWSING_SAFE_BROWSING_DATABASE_H_