Each DatabaseManager gets to decide which stores to track

components/safe_browsing_db/v4_get_hash_protocol_manager.cc

 // 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.
 
 #include "components/safe_browsing_db/v4_get_hash_protocol_manager.h"
 
 #include <utility>
 
 #include "base/base64url.h"
 #include "base/macros.h"
@@ skipping 122 matching lines @@
     "SafeBrowsing.GetV4HashHttpResponseOrErrorCode";
 
 // The default V4GetHashProtocolManagerFactory.
 class V4GetHashProtocolManagerFactoryImpl
     : public V4GetHashProtocolManagerFactory {
  public:
   V4GetHashProtocolManagerFactoryImpl() {}
   ~V4GetHashProtocolManagerFactoryImpl() override {}
   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) override {
     return base::WrapUnique(new V4GetHashProtocolManager(
         request_context_getter, stores_to_request, config));
   }
 
  private:
   DISALLOW_COPY_AND_ASSIGN(V4GetHashProtocolManagerFactoryImpl);
 };
 
 // ----------------------------------------------------------------
@@ skipping 48 matching lines @@
 }
 
 // V4GetHashProtocolManager implementation --------------------------------
 
 // static
 V4GetHashProtocolManagerFactory* V4GetHashProtocolManager::factory_ = NULL;
 
 // static
 std::unique_ptr<V4GetHashProtocolManager> 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) {
   if (!factory_)
     factory_ = new V4GetHashProtocolManagerFactoryImpl();
   return factory_->CreateProtocolManager(request_context_getter,
                                          stores_to_request, config);
 }
 
 // static
 void V4GetHashProtocolManager::RegisterFactory(
     std::unique_ptr<V4GetHashProtocolManagerFactory> factory) {
   if (factory_)
     delete factory_;
   factory_ = factory.release();
 }
 
 V4GetHashProtocolManager::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)
     : gethash_error_count_(0),
       gethash_back_off_mult_(1),
       next_gethash_time_(Time::FromDoubleT(0)),
       config_(config),
       request_context_getter_(request_context_getter),
       url_fetcher_id_(0),
       clock_(new base::DefaultClock()) {
   DCHECK(!stores_to_request.empty());
   for (const UpdateListIdentifier& store : stores_to_request) {
@@ skipping 60 matching lines @@
   fetcher->SetLoadFlags(net::LOAD_DISABLE_CACHE);
   fetcher->SetRequestContext(request_context_getter_.get());
   fetcher->Start();
 }
 
 void V4GetHashProtocolManager::GetFullHashesWithApis(
     const GURL& url,
     ThreatMetadataForApiCallback api_callback) {
   DCHECK(url.SchemeIs(url::kHttpScheme) || url.SchemeIs(url::kHttpsScheme));
 
-  base::hash_set<FullHash> full_hashes;
+  std::unordered_set<FullHash> full_hashes;
   V4ProtocolManagerUtil::UrlToFullHashes(url, &full_hashes);
 
   FullHashToStoreAndHashPrefixesMap full_hash_to_store_and_hash_prefixes;
   for (const FullHash& full_hash : full_hashes) {
     HashPrefix prefix;
     bool result =
         V4ProtocolManagerUtil::FullHashToSmallestHashPrefix(full_hash, &prefix);
     DCHECK(result);
     full_hash_to_store_and_hash_prefixes[full_hash].emplace_back(
         GetChromeUrlApiId(), prefix);
@@ skipping 36 matching lines @@
   //             We need to send a request for full hashes.
   //
   // Note on eviction:
   //   CachedHashPrefixInfo entries can be removed from the cache only when
   //   the negative cache expire time and the cache expire time of all full
   //   hash results for that prefix have expired.
   //   Individual full hash results can be removed from the prefix's
   //   cache entry if they expire AND their expire time is after the negative
   //   cache expire time.
 
-  base::hash_set<HashPrefix> unique_prefixes_to_request;
+  std::unordered_set<HashPrefix> unique_prefixes_to_request;
   for (const auto& it : full_hash_to_store_and_hash_prefixes) {
     const FullHash& full_hash = it.first;
     const StoreAndHashPrefixes& matched = it.second;
     for (const StoreAndHashPrefix& matched_it : matched) {
       const UpdateListIdentifier& list_id = matched_it.list_id;
       const HashPrefix& prefix = matched_it.hash_prefix;
       auto prefix_entry = full_hash_cache_.find(prefix);
       if (prefix_entry != full_hash_cache_.end()) {
         // Case 1.
         const CachedHashPrefixInfo& cached_prefix_info = prefix_entry->second;
@@ skipping 78 matching lines @@
 
 void V4GetHashProtocolManager::HandleGetHashError(const Time& now) {
   DCHECK(CalledOnValidThread());
   TimeDelta next = V4ProtocolManagerUtil::GetNextBackOffInterval(
       &gethash_error_count_, &gethash_back_off_mult_);
   next_gethash_time_ = now + next;
 }
 
 void V4GetHashProtocolManager::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) {
   ThreatMetadata md;
   for (const FullHashInfo& full_hash_info : full_hash_infos) {
     DCHECK_EQ(GetChromeUrlApiId(), full_hash_info.list_id);
     DCHECK(full_hashes.find(full_hash_info.full_hash) != full_hashes.end());
     md.api_permissions.insert(full_hash_info.metadata.api_permissions.begin(),
                               full_hash_info.metadata.api_permissions.end());
   }
 
   api_callback.Run(md);
@@ skipping 252 matching lines @@
 std::ostream& operator<<(std::ostream& os, const FullHashInfo& fhi) {
   os << "{full_hash: " << fhi.full_hash << "; list_id: " << fhi.list_id
      << "; positive_expiry: " << fhi.positive_expiry
      << "; metadata.api_permissions.size(): "
      << fhi.metadata.api_permissions.size() << "}";
   return os;
 }
 #endif
 
 }  // namespace safe_browsing