PVer4: Test checksum on startup outside the hotpath of DB load

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/debug/leak_annotations.h"
 #include "base/files/file_util.h"
 #include "base/memory/ptr_util.h"
@@ skipping 51 matching lines @@
     }
 
     const base::FilePath store_path = base_path.AppendASCII(it.filename());
     (*store_map)[it.list_id()].reset(
         factory_->CreateV4Store(db_task_runner, store_path));
   }
   std::unique_ptr<V4Database> v4_database(
       new V4Database(db_task_runner, std::move(store_map)));
 
   // Database is done loading, pass it to the new_db_callback on the caller's
-  // thread.
+  // thread. This would unblock URL navigation.

[Nathan Parker, 2016/10/07 23:24:28]

nit: URL resource loads (not just navigation... so, resources on the NTP will
also be blocked until here)

[vakh (use Gerrit instead), 2016/10/10 17:42:33]

Done.

   callback_task_runner->PostTask(
       FROM_HERE, base::Bind(new_db_callback, base::Passed(&v4_database)));
 }
 
 V4Database::V4Database(
     const scoped_refptr<base::SequencedTaskRunner>& db_task_runner,
     std::unique_ptr<StoreMap> store_map)
     : db_task_runner_(db_task_runner),
       store_map_(std::move(store_map)),
       pending_store_updates_(0) {
   DCHECK(db_task_runner->RunsTasksOnCurrentThread());
-  // TODO(vakh): Implement skeleton
 }
 
 // static
 void V4Database::Destroy(std::unique_ptr<V4Database> v4_database) {
+  DCHECK_CURRENTLY_ON(BrowserThread::IO);
   V4Database* v4_database_raw = v4_database.release();
   if (v4_database_raw) {
     v4_database_raw->db_task_runner_->DeleteSoon(FROM_HERE, v4_database_raw);
   }
 }
 
 V4Database::~V4Database() {
   DCHECK(db_task_runner_->RunsTasksOnCurrentThread());
 }
 
@@ skipping 46 matching lines @@
     (*store_map_)[identifier] = std::move(new_store);
   }
 
   pending_store_updates_--;
   if (!pending_store_updates_) {
     db_updated_callback_.Run();
     db_updated_callback_.Reset();
   }
 }
 
-bool V4Database::ResetDatabase() {
-  DCHECK(db_task_runner_->RunsTasksOnCurrentThread());
-  bool reset_success = true;
-  for (const auto& store_map_iter : *store_map_) {
-    if (!store_map_iter.second->Reset()) {
-      reset_success = false;
-    }
-  }
-  return reset_success;
-}
-
 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;
 }
 
 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) {
     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);
     }
   }
 }
 
+void V4Database::ResetStores(
+    const std::vector<ListIdentifier>& stores_to_reset) {
+  DCHECK_CURRENTLY_ON(BrowserThread::IO);
+  for (const ListIdentifier& identifier : stores_to_reset) {
+    const auto& store_pair = store_map_->find(identifier);
+    DCHECK(store_pair != store_map_->end());
+    store_pair->second->Reset();
+  }
+}
+
+void V4Database::VerifyChecksum(
+    DatabaseReadyForUpdatesCallback db_ready_for_updates_callback) {
+  DCHECK_CURRENTLY_ON(BrowserThread::IO);
+  const scoped_refptr<base::SingleThreadTaskRunner> callback_task_runner =
+      base::ThreadTaskRunnerHandle::Get();
+  db_task_runner_->PostTask(
+      FROM_HERE, base::Bind(&V4Database::VerifyChecksumOnTaskRunner,

[Nathan Parker, 2016/10/07 23:24:28]

An aside: I think you could have used PostTaskAndReply for this thread hopping,
though I'm not convinced it'd be easier to understand (it'd just be less code).

[vakh (use Gerrit instead), 2016/10/10 17:42:33]

You're right that it'd be less code and it also guarantees that the callback is
run on the same thread as PostTaskAndReply so we won't need to get
callback_task_runner but I think it might be better to like at look at all
PostTask calls in this file and convert them all together. I'll add a TODO for
that. 

+                            base::Unretained(this), callback_task_runner,
+                            db_ready_for_updates_callback));
+}
+
+void V4Database::VerifyChecksumOnTaskRunner(
+    const scoped_refptr<base::SingleThreadTaskRunner>& callback_task_runner,
+    DatabaseReadyForUpdatesCallback db_ready_for_updates_callback) {
+  std::vector<ListIdentifier> stores_to_reset;
+  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));
+}
+
 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