Browser tests for using the new SafeBrowsing protocol (v4)

components/safe_browsing_db/v4_local_database_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.
 
 // This file should not be build on Android but is currently getting built.
 // TODO(vakh): Fix that: http://crbug.com/621647
 
 #include "components/safe_browsing_db/v4_local_database_manager.h"
 
 #include <vector>
@@ skipping 112 matching lines @@
       stores_to_check(stores_to_check) {
   full_hashes.assign(full_hashes_set.begin(), full_hashes_set.end());
 }
 
 V4LocalDatabaseManager::PendingCheck::~PendingCheck() {}
 
 // static
 scoped_refptr<V4LocalDatabaseManager> V4LocalDatabaseManager::Create(
     const base::FilePath& base_path,
     ExtendedReportingLevelCallback extended_reporting_level_callback) {
-  if (!V4FeatureList::IsLocalDatabaseManagerEnabled()) {
-    return nullptr;
-  }
-
   return make_scoped_refptr(
       new V4LocalDatabaseManager(base_path, extended_reporting_level_callback));
 }
 
 V4LocalDatabaseManager::V4LocalDatabaseManager(
     const base::FilePath& base_path,
     ExtendedReportingLevelCallback extended_reporting_level_callback)
     : base_path_(base_path),
       extended_reporting_level_callback_(extended_reporting_level_callback),
       list_infos_(GetListInfos()),
@@ skipping 45 matching lines @@
          url.SchemeIs(url::kFtpScheme);
 }
 
 bool V4LocalDatabaseManager::ChecksAreAlwaysAsync() const {
   return false;
 }
 
 bool V4LocalDatabaseManager::CheckBrowseUrl(const GURL& url, Client* client) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
 
+  LOG(ERROR) << "V4LocalDatabaseManager::CheckBrowseUrl: url: " << url.spec();

[Scott Hess - ex-Googler, 2017/02/06 22:46:36]

Does everyone need to see these logs?

[vakh (use Gerrit instead), 2017/02/06 23:30:13]

No, got uploaded by mistake. Removed.

+
   if (!enabled_ || !CanCheckUrl(url)) {
     return true;
   }
 
+  LOG(ERROR) << "V4LocalDatabaseManager::CheckBrowseUrl: url: " << url.spec();
   std::unique_ptr<PendingCheck> check = base::MakeUnique<PendingCheck>(
       client, ClientCallbackType::CHECK_BROWSE_URL,
       StoresToCheck({GetUrlMalwareId(), GetUrlSocEngId(), GetUrlUwsId()}),
       std::vector<GURL>(1, url));
 
   return HandleCheck(std::move(check));
 }
 
 bool V4LocalDatabaseManager::CheckDownloadUrl(
     const std::vector<GURL>& url_chain,
@@ skipping 246 matching lines @@
       check->client_callback_type == ClientCallbackType::CHECK_RESOURCE_URL ||
       check->client_callback_type == ClientCallbackType::CHECK_EXTENSION_IDS ||
       check->client_callback_type == ClientCallbackType::CHECK_OTHER) {
     DCHECK(!check->full_hashes.empty());
 
     full_hash_to_store_and_hash_prefixes->clear();
     for (const auto& full_hash : check->full_hashes) {
       StoreAndHashPrefixes matched_store_and_hash_prefixes;
       v4_database_->GetStoresMatchingFullHash(full_hash, check->stores_to_check,
                                               &matched_store_and_hash_prefixes);
+      LOG(ERROR) << "V4LocalDatabaseManager::GetPrefixMatches: matched: "
+                 << !matched_store_and_hash_prefixes.empty();
       if (!matched_store_and_hash_prefixes.empty()) {
         (*full_hash_to_store_and_hash_prefixes)[full_hash] =
             matched_store_and_hash_prefixes;
       }
     }
   } else {
     NOTREACHED() << "Unexpected client_callback_type encountered.";
   }
 
   // TODO(vakh): Only log SafeBrowsing.V4GetPrefixMatches.Time once PVer3 code
@@ skipping 44 matching lines @@
   auto it = std::find_if(
       std::begin(list_infos_), std::end(list_infos_),
       [&list_id](ListInfo const& li) { return li.list_id() == list_id; });
   DCHECK(list_infos_.end() != it);
   DCHECK_NE(SB_THREAT_TYPE_SAFE, it->sb_threat_type());
   DCHECK_NE(SB_THREAT_TYPE_UNUSED, it->sb_threat_type());
   return it->sb_threat_type();
 }
 
 bool V4LocalDatabaseManager::HandleCheck(std::unique_ptr<PendingCheck> check) {
+  LOG(ERROR) << "V4LocalDatabaseManager::HandleCheck: v4_database_: "
+             << v4_database_.get();
   if (!v4_database_) {
     queued_checks_.push_back(std::move(check));
     return false;
   }
 
   FullHashToStoreAndHashPrefixesMap full_hash_to_store_and_hash_prefixes;
   if (!GetPrefixMatches(check, &full_hash_to_store_and_hash_prefixes)) {
+    LOG(ERROR) << "V4LocalDatabaseManager::HandleCheck: No prefix match!";
     return true;
   }
 
+  LOG(ERROR) << "V4LocalDatabaseManager::HandleCheck: Prefix(es) matched!";
   // Add check to pending_checks_ before scheduling PerformFullHashCheck so that
   // even if the client calls CancelCheck before PerformFullHashCheck gets
   // called, the check can be found in pending_checks_.
   pending_checks_.insert(check.get());
 
   // Post on the IO thread to enforce async behavior.
   BrowserThread::PostTask(
       BrowserThread::IO, FROM_HERE,
       base::Bind(&V4LocalDatabaseManager::PerformFullHashCheck, this,
                  base::Passed(std::move(check)),
@@ skipping 26 matching lines @@
 
   FullHashToStoreAndHashPrefixesMap full_hash_to_store_and_hash_prefixes;
   return GetPrefixMatches(check, &full_hash_to_store_and_hash_prefixes);
 }
 
 void V4LocalDatabaseManager::OnFullHashResponse(
     std::unique_ptr<PendingCheck> check,
     const std::vector<FullHashInfo>& full_hash_infos) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
 
+  LOG(ERROR)
+      << "V4LocalDatabaseManager::OnFullHashResponse: full_hash_infos.size(): "
+      << full_hash_infos.size();
+  LOG(ERROR) << "V4LocalDatabaseManager::OnFullHashResponse: enabled_: "
+             << enabled_;
+
   if (!enabled_) {
     DCHECK(pending_checks_.empty());
     return;
   }
 
   const auto it = pending_checks_.find(check.get());
   if (it == pending_checks_.end()) {
     // The check has since been cancelled.
     return;
   }
 
   // Find out the most severe threat, if any, to report to the client.
   GetSeverestThreatTypeAndMetadata(&check->result_threat_type,
                                    &check->url_metadata,
                                    &check->matching_full_hash, full_hash_infos);
+  LOG(ERROR) << "V4LocalDatabaseManager::OnFullHashResponse: "
+                "check->result_threat_type: "
+             << check->result_threat_type;
   pending_checks_.erase(it);
   RespondToClient(std::move(check));
 }
 
 void V4LocalDatabaseManager::PerformFullHashCheck(
     std::unique_ptr<PendingCheck> check,
     const FullHashToStoreAndHashPrefixesMap&
         full_hash_to_store_and_hash_prefixes) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
 
@@ skipping 111 matching lines @@
                             db_updated_callback_);
 }
 
 bool V4LocalDatabaseManager::AreStoresAvailableNow(
     const StoresToCheck& stores_to_check) const {
   return enabled_ && v4_database_ &&
          v4_database_->AreStoresAvailable(stores_to_check);
 }
 
 }  // namespace safe_browsing