Ignore ThreatMatch responses for lists that we don't care about.

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"
 #include "base/memory/ptr_util.h"
 #include "base/metrics/histogram_macros.h"
+#include "base/stl_util.h"
 #include "base/timer/timer.h"
 #include "content/public/browser/browser_thread.h"
 #include "net/base/load_flags.h"
 #include "net/http/http_response_headers.h"
 #include "net/http/http_status_code.h"
 #include "net/url_request/url_fetcher.h"
 #include "net/url_request/url_request_context_getter.h"
 
 using base::Time;
 using base::TimeDelta;
@@ skipping 208 matching lines @@
     const StoresToCheck& stores_to_check,
     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_check.empty());
+  std::set<PlatformType> platform_types;
+  std::set<ThreatEntryType> threat_entry_types;
+  std::set<ThreatType> threat_types;
   for (const ListIdentifier& store : stores_to_check) {
-    platform_types_.insert(store.platform_type());
-    threat_entry_types_.insert(store.threat_entry_type());
-    threat_types_.insert(store.threat_type());
+    platform_types.insert(store.platform_type());
+    threat_entry_types.insert(store.threat_entry_type());
+    threat_types.insert(store.threat_type());
   }
+  platform_types_.assign(platform_types.begin(), platform_types.end());
+  threat_entry_types_.assign(threat_entry_types.begin(),
+                             threat_entry_types.end());
+  threat_types_.assign(threat_types.begin(), threat_types.end());
 }
 
 V4GetHashProtocolManager::~V4GetHashProtocolManager() {}
 
 void V4GetHashProtocolManager::ClearCache() {
   DCHECK(CalledOnValidThread());
   full_hash_cache_.clear();
 }
 
 void V4GetHashProtocolManager::GetFullHashes(
@@ skipping 266 matching lines @@
       RecordParseGetHashResult(UNEXPECTED_THREAT_TYPE_ERROR);
       return false;
     }
     if (!match.has_threat()) {
       RecordParseGetHashResult(NO_THREAT_ERROR);
       return false;
     }
 
     ListIdentifier list_id(match.platform_type(), match.threat_entry_type(),
                            match.threat_type());
+    if (!base::ContainsValue(platform_types_, list_id.platform_type()) ||
+        !base::ContainsValue(threat_entry_types_,
+                             list_id.threat_entry_type()) ||
+        !base::ContainsValue(threat_types_, list_id.threat_type())) {
+      // The server may send a ThreatMatch response for lists that we didn't ask
+      // for so ignore those ThreatMatch responses.
+      continue;
+    }
+
     base::Time positive_expiry;
     if (match.has_cache_duration()) {
       // Seconds resolution is good enough so we ignore the nanos field.
       positive_expiry = clock_->Now() + TimeDelta::FromSeconds(
                                             match.cache_duration().seconds());
     } else {
       positive_expiry = clock_->Now() - base::TimeDelta::FromSeconds(1);
     }
     FullHashInfo full_hash_info(match.threat().hash(), list_id,
                                 positive_expiry);
@@ skipping 194 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