Add the SocEng as a type for checking in CheckUrlForSubresourceFilter.

components/safe_browsing_db/v4_database.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 <memory>
 
 #include "base/callback.h"
 #include "base/files/file_util.h"
 #include "base/lazy_instance.h"
 #include "base/memory/ptr_util.h"
@@ skipping 186 matching lines @@
 
 std::unique_ptr<StoreStateMap> V4Database::GetStoreStateMap() {
   std::unique_ptr<StoreStateMap> store_state_map =
       base::MakeUnique<StoreStateMap>();
   for (const auto& store_map_iter : *store_map_) {
     (*store_state_map)[store_map_iter.first] = store_map_iter.second->state();
   }
   return store_state_map;
 }
 
 bool V4Database::AreStoresAvailable(

[Nathan Parker, 2017/05/12 17:30:10]

I had the following comment on an earlier vers, and couldn't find a response. 
Since you're changing the semantics of this function:

I think we'd need two versions: 
  AreAllStoresAvailable()
  AreAnyStoresAvailable()
And plumb that up through V4LocalDatabaseManager so it's really clear in the
Check*() calls what the requirements are.

[melandory, 2017/05/15 14:57:25]

Sorry, haven't noticed it earlier. Done.

     const StoresToCheck& stores_to_check) const {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
   for (const ListIdentifier& identifier : stores_to_check) {
-    const auto& store_pair = store_map_->find(identifier);
-    if (store_pair == store_map_->end()) {
-      return false;  // Store not in our list
-    }
-    if (!store_pair->second->HasValidData()) {
-      return false;  // Store never properly populated.
-    }
+    if (IsStoreAvailable(identifier))
+      return true;
   }
-  return true;
+  return false;
 }
 
 void V4Database::GetStoresMatchingFullHash(
     const FullHash& full_hash,
     const StoresToCheck& stores_to_check,
     StoreAndHashPrefixes* matched_store_and_hash_prefixes) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
   matched_store_and_hash_prefixes->clear();
   for (const ListIdentifier& identifier : stores_to_check) {
+    if (!IsStoreAvailable(identifier))
+      continue;
     const auto& store_pair = store_map_->find(identifier);
     DCHECK(store_pair != store_map_->end());
     const std::unique_ptr<V4Store>& store = store_pair->second;
     HashPrefix hash_prefix = store->GetMatchingHashPrefix(full_hash);
     if (!hash_prefix.empty()) {
       matched_store_and_hash_prefixes->emplace_back(identifier, hash_prefix);
     }
   }
 }
 
@@ skipping 25 matching lines @@
   for (const auto& store_map_iter : *store_map_) {
     if (!store_map_iter.second->VerifyChecksum()) {
       stores_to_reset.push_back(store_map_iter.first);
     }
   }
 
   callback_task_runner->PostTask(
       FROM_HERE, base::Bind(db_ready_for_updates_callback, stores_to_reset));
 }
 
+bool V4Database::IsStoreAvailable(const ListIdentifier& identifier) const {
+  const auto& store_pair = store_map_->find(identifier);
+  if (store_pair == store_map_->end()) {
+    // Store not in our list
+    return false;
+  }
+  if (!store_pair->second->HasValidData()) {
+    // Store never properly populated
+    return false;
+  }
+  return true;
+}
+
 void V4Database::RecordFileSizeHistograms() {
   int64_t db_size = 0;
   for (const auto& store_map_iter : *store_map_) {
     const int64_t size =
         store_map_iter.second->RecordAndReturnFileSize(kV4DatabaseSizeMetric);
     db_size += size;
   }
   const int64_t db_size_kilobytes = static_cast<int64_t>(db_size / 1024);
   UMA_HISTOGRAM_COUNTS(kV4DatabaseSizeMetric, db_size_kilobytes);
 }
 
 ListInfo::ListInfo(const bool fetch_updates,
                    const std::string& filename,
                    const ListIdentifier& list_id,
                    const SBThreatType sb_threat_type)
     : fetch_updates_(fetch_updates),
       filename_(filename),
       list_id_(list_id),
       sb_threat_type_(sb_threat_type) {
   DCHECK(!fetch_updates_ || !filename_.empty());
   DCHECK_NE(SB_THREAT_TYPE_SAFE, sb_threat_type_);
 }
 
 ListInfo::~ListInfo() {}
 
 }  // namespace safe_browsing