Each DatabaseManager gets to decide which stores to track

components/safe_browsing_db/v4_get_hash_protocol_manager.h

 // Copyright 2016 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 COMPONENTS_SAFE_BROWSING_DB_V4_GET_HASH_PROTOCOL_MANAGER_H_
 #define COMPONENTS_SAFE_BROWSING_DB_V4_GET_HASH_PROTOCOL_MANAGER_H_
 
 // A class that implements Chrome's interface with the SafeBrowsing V4 protocol.
 //
 // The V4GetHashProtocolManager handles formatting and making requests of, and
@@ skipping 129 matching lines @@
   // Parameters:
   //   - The API threat metadata for the given URL.
   typedef base::Callback<void(const ThreatMetadata& md)>
       ThreatMetadataForApiCallback;
 
   ~V4GetHashProtocolManager() override;
 
   // Create an instance of the safe browsing v4 protocol manager.
   static std::unique_ptr<V4GetHashProtocolManager> Create(
       net::URLRequestContextGetter* request_context_getter,
-      const base::hash_set<UpdateListIdentifier>& stores_to_request,
+      const std::unordered_set<UpdateListIdentifier>& stores_to_request,
       const V4ProtocolConfig& config);
 
   // Makes the passed |factory| the factory used to instantiate
   // a V4GetHashProtocolManager. Useful for tests.
   static void RegisterFactory(
       std::unique_ptr<V4GetHashProtocolManagerFactory> factory);
 
   // Empties the cache.
   void ClearCache();
 
@@ skipping 19 matching lines @@
                                      ThreatMetadataForApiCallback api_callback);
 
   // net::URLFetcherDelegate interface.
   void OnURLFetchComplete(const net::URLFetcher* source) override;
 
  protected:
   // Constructs a V4GetHashProtocolManager that issues
   // network requests using |request_context_getter|.
   V4GetHashProtocolManager(
       net::URLRequestContextGetter* request_context_getter,
-      const base::hash_set<UpdateListIdentifier>& stores_to_request,
+      const std::unordered_set<UpdateListIdentifier>& stores_to_request,
       const V4ProtocolConfig& config);
 
  private:
   FRIEND_TEST_ALL_PREFIXES(V4GetHashProtocolManagerTest, TestGetHashRequest);
   FRIEND_TEST_ALL_PREFIXES(V4GetHashProtocolManagerTest, TestParseHashResponse);
   FRIEND_TEST_ALL_PREFIXES(V4GetHashProtocolManagerTest,
                            TestParseHashResponseWrongThreatEntryType);
   FRIEND_TEST_ALL_PREFIXES(V4GetHashProtocolManagerTest,
                            TestParseHashThreatPatternType);
   FRIEND_TEST_ALL_PREFIXES(V4GetHashProtocolManagerTest,
@@ skipping 47 matching lines @@
   // results that the client did not ask for.
   void MergeResults(const FullHashToStoreAndHashPrefixesMap&
                         full_hash_to_store_and_hash_prefixes,
                     const std::vector<FullHashInfo>& full_hash_infos,
                     std::vector<FullHashInfo>* merged_full_hash_infos);
 
   // Calls |api_callback| with an object of ThreatMetadata that contains
   // permission API metadata for full hashes in those |full_hash_infos| that
   // have a full hash in |full_hashes|.
   void OnFullHashForApi(const ThreatMetadataForApiCallback& api_callback,
-                        const base::hash_set<FullHash>& full_hashes,
+                        const std::unordered_set<FullHash>& full_hashes,
                         const std::vector<FullHashInfo>& full_hash_infos);
 
   // Parses a FindFullHashesResponse protocol buffer and fills the results in
   // |full_hash_infos| and |negative_cache_expire|. |response_data| is a
   // serialized FindFullHashes protocol buffer. |negative_cache_expire| is the
   // cache expiry time of the hash prefixes that were requested. Returns true if
   // parsing is successful; false otherwise.
   bool ParseHashResponse(const std::string& response_data,
                          std::vector<FullHashInfo>* full_hash_infos,
                          base::Time* negative_cache_expire);
@@ skipping 55 matching lines @@
 
   // The clock used to vend times.
   std::unique_ptr<base::Clock> clock_;
 
   // A cache of full hash results.
   FullHashCache full_hash_cache_;
 
   // The following sets represent the combination of lists that we would always
   // request from the server, irrespective of which list we found the hash
   // prefix match in.
-  base::hash_set<PlatformType> platform_types_;
-  base::hash_set<ThreatEntryType> threat_entry_types_;
-  base::hash_set<ThreatType> threat_types_;
+  std::unordered_set<PlatformType> platform_types_;
+  std::unordered_set<ThreatEntryType> threat_entry_types_;
+  std::unordered_set<ThreatType> threat_types_;
 
   DISALLOW_COPY_AND_ASSIGN(V4GetHashProtocolManager);
 };
 
 // Interface of a factory to create V4GetHashProtocolManager.  Useful for tests.
 class V4GetHashProtocolManagerFactory {
  public:
   V4GetHashProtocolManagerFactory() {}
   virtual ~V4GetHashProtocolManagerFactory() {}
   virtual std::unique_ptr<V4GetHashProtocolManager> CreateProtocolManager(
       net::URLRequestContextGetter* request_context_getter,
-      const base::hash_set<UpdateListIdentifier>& stores_to_request,
+      const std::unordered_set<UpdateListIdentifier>& stores_to_request,
       const V4ProtocolConfig& config) = 0;
 
  private:
   DISALLOW_COPY_AND_ASSIGN(V4GetHashProtocolManagerFactory);
 };
 
 #ifndef NDEBUG
 std::ostream& operator<<(std::ostream& os, const FullHashInfo& id);
 #endif
 
 }  // namespace safe_browsing
 
 #endif  // COMPONENTS_SAFE_BROWSING_DB_V4_GET_HASH_PROTOCOL_MANAGER_H_