Make SafeBrowsingDatabase's PrefixSets only updatable by swapping a new one in.

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 349 matching lines @@
   // lookups in the whitelist should be considered matches for safety.
   typedef std::pair<std::vector<SBFullHash>, bool> SBWhitelist;
 
   // This map holds a csd malware IP blacklist which maps a prefix mask
   // to a set of hashed blacklisted IP prefixes.  Each IP prefix is a hashed
   // IPv6 IP prefix using SHA-1.
   typedef std::map<std::string, base::hash_set<std::string> > IPBlacklist;
 
   bool PrefixSetContainsUrl(
       const GURL& url,
-      scoped_ptr<safe_browsing::PrefixSet>* prefix_set_getter,
+      scoped_ptr<const safe_browsing::PrefixSet>* prefix_set_getter,
       std::vector<SBPrefix>* prefix_hits,
       std::vector<SBFullHashResult>* cache_hits);
 
   // Exposed for testing of PrefixSetContainsUrlHashes() on the
   // PrefixSet backing kMalwareList.
   bool ContainsBrowseUrlHashesForTesting(
       const std::vector<SBFullHash>& full_hashes,
       std::vector<SBPrefix>* prefix_hits,
       std::vector<SBFullHashResult>* cache_hits);
 
   bool PrefixSetContainsUrlHashes(
       const std::vector<SBFullHash>& full_hashes,
-      scoped_ptr<safe_browsing::PrefixSet>* prefix_set_getter,
+      scoped_ptr<const safe_browsing::PrefixSet>* prefix_set_getter,
       std::vector<SBPrefix>* prefix_hits,
       std::vector<SBFullHashResult>* cache_hits);
 
   // Returns true if the whitelist is disabled or if any of the given hashes
   // matches the whitelist.
   bool ContainsWhitelistedHashes(const SBWhitelist& whitelist,
                                  const std::vector<SBFullHash>& hashes);
 
   // Return the browse_store_, download_store_, download_whitelist_store or
   // csd_whitelist_store_ based on list_id.
   SafeBrowsingStore* GetStore(int list_id);
 
   // Deletes the files on disk.
   bool Delete();
 
   // Load the prefix set in "|db_filename| Prefix Set" off disk, if available,
   // and stores it in |prefix_set|.  |read_failure_type| provides a
   // caller-specific error code to be used on failure.
   void LoadPrefixSet(const base::FilePath& db_filename,
-                     scoped_ptr<safe_browsing::PrefixSet>* prefix_set,
+                     scoped_ptr<const safe_browsing::PrefixSet>* prefix_set,
                      FailureType read_failure_type);
 
   // Writes the current prefix set "|db_filename| Prefix Set" on disk.
   // |write_failure_type| provides a caller-specific error code to be used on
   // failure.
   void WritePrefixSet(const base::FilePath& db_filename,
-                      safe_browsing::PrefixSet* prefix_set,
+                      const safe_browsing::PrefixSet* prefix_set,
                       FailureType write_failure_type);
 
   // Loads the given full-length hashes to the given whitelist.  If the number
   // of hashes is too large or if the kill switch URL is on the whitelist
   // we will whitelist everything.
   void LoadWhitelist(const std::vector<SBAddFullHash>& full_hashes,
                      SBWhitelist* whitelist);
 
   // Call this method if an error occured with the given whitelist.  This will
   // result in all lookups to the whitelist to return true.
@@ skipping 21 matching lines @@
                       const SBChunkData& chunk);
 
   // Returns the size in bytes of the store after the update.
   int64 UpdateHashPrefixStore(const base::FilePath& store_filename,
                                SafeBrowsingStore* store,
                                FailureType failure_type);
 
   // Updates a PrefixStore store for URLs (|url_store|) which is backed on disk
   // by a "|db_filename| Prefix Set" file. Specific failure types are provided
   // to highlight the specific store who made the initial request on failure.
-  void UpdatePrefixSetUrlStore(const base::FilePath& db_filename,
-                               SafeBrowsingStore* url_store,
-                               scoped_ptr<safe_browsing::PrefixSet>* prefix_set,
-                               FailureType finish_failure_type,
-                               FailureType write_failure_type);
+  void UpdatePrefixSetUrlStore(
+      const base::FilePath& db_filename,
+      SafeBrowsingStore* url_store,
+      scoped_ptr<const safe_browsing::PrefixSet>* prefix_set,
+      FailureType finish_failure_type,
+      FailureType write_failure_type);
 
   void UpdateUrlStore(SafeBrowsingStore* url_store,
-                      scoped_ptr<safe_browsing::PrefixSet>* prefix_set,
+                      scoped_ptr<const safe_browsing::PrefixSet>* prefix_set,
                       FailureType failure_type);
 
   void UpdateSideEffectFreeWhitelistStore();
   void UpdateWhitelistStore(const base::FilePath& store_filename,
                             SafeBrowsingStore* store,
                             SBWhitelist* whitelist);
   void UpdateIpBlacklistStore();
 
   // Used to verify that various calls are made from the thread the
   // object was created on (i.e., the safe_browsing_thread).
@@ skipping 49 matching lines @@
 
   // Set if corruption is detected during the course of an update.
   // Causes the update functions to fail with no side effects, until
   // the next call to |UpdateStarted()|.
   bool corruption_detected_;
 
   // Set to true if any chunks are added or deleted during an update.
   // Used to optimize away database update.
   bool change_detected_;
 
-  // Used to check if a prefix was in the browse database.
-  scoped_ptr<safe_browsing::PrefixSet> browse_prefix_set_;
-
-  // Used to check if a prefix was in the side-effect free whitelist database.
-  scoped_ptr<safe_browsing::PrefixSet> side_effect_free_whitelist_prefix_set_;
-
-  // Used to check if a prexfix was in the unwanted software database.
-  scoped_ptr<safe_browsing::PrefixSet> unwanted_software_prefix_set_;
+  // PrefixSets to speed up lookups for particularly large lists. The PrefixSet
+  // themselves are never modified, instead a new one is swapped in on update
+  // while holding |lookup_lock_|. Any thread other than this class' main thread
+  // (which handles updates) must hold |lookup_lock_| before reading from these
+  // sets.
+  // TODO(gab): Enforce this by design.
+  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_;
 
   // Used to schedule resetting the database because of corruption.
   base::WeakPtrFactory<SafeBrowsingDatabaseNew> reset_factory_;
 };
 
 #endif  // CHROME_BROWSER_SAFE_BROWSING_SAFE_BROWSING_DATABASE_H_