V4LDBM: Get response from GetHashManager, detect severest result

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/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;
+using content::BrowserThread;
 
 namespace {
 
 // Record a GetHash result.
 void RecordGetHashResult(safe_browsing::V4OperationResult result) {
   UMA_HISTOGRAM_ENUMERATION(
       "SafeBrowsing.GetV4HashResult", result,
       safe_browsing::V4OperationResult::OPERATION_RESULT_MAX);
 }
 
@@ skipping 216 matching lines @@
 
 void V4GetHashProtocolManager::ClearCache() {
   DCHECK(CalledOnValidThread());
   full_hash_cache_.clear();
 }
 
 void V4GetHashProtocolManager::GetFullHashes(
     const FullHashToStoreAndHashPrefixesMap&
         full_hash_to_store_and_hash_prefixes,
     FullHashCallback callback) {
+  DCHECK_CURRENTLY_ON(BrowserThread::IO);
   DCHECK(CalledOnValidThread());
   DCHECK(!full_hash_to_store_and_hash_prefixes.empty());
 
   std::vector<HashPrefix> prefixes_to_request;
   std::vector<FullHashInfo> cached_full_hash_infos;
   GetFullHashCachedResults(full_hash_to_store_and_hash_prefixes, Time::Now(),
                            &prefixes_to_request, &cached_full_hash_infos);
 
   if (prefixes_to_request.empty()) {
     // 100% cache hits (positive or negative) so we can call the callback right
@@ skipping 31 matching lines @@
 
   fetcher->SetExtraRequestHeaders(headers.ToString());
   fetcher->SetLoadFlags(net::LOAD_DISABLE_CACHE);
   fetcher->SetRequestContext(request_context_getter_.get());
   fetcher->Start();
 }
 
 void V4GetHashProtocolManager::GetFullHashesWithApis(
     const GURL& url,
     ThreatMetadataForApiCallback api_callback) {
+  DCHECK_CURRENTLY_ON(BrowserThread::IO);
   DCHECK(url.SchemeIs(url::kHttpScheme) || url.SchemeIs(url::kHttpsScheme));
 
   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);
@@ skipping 303 matching lines @@
 
 void V4GetHashProtocolManager::SetClockForTests(
     std::unique_ptr<base::Clock> clock) {
   clock_ = std::move(clock);
 }
 
 void V4GetHashProtocolManager::UpdateCache(
     const std::vector<HashPrefix>& prefixes_requested,
     const std::vector<FullHashInfo>& full_hash_infos,
     const Time& negative_cache_expire) {
+  DCHECK_CURRENTLY_ON(BrowserThread::IO);
+
   // If negative_cache_expire is null, don't cache the results since it's not
   // clear till what time they should be considered valid.
   if (negative_cache_expire.is_null()) {
     return;
   }
 
   for (const HashPrefix& prefix : prefixes_requested) {
     // Create or reset the cached result for this prefix.
     CachedHashPrefixInfo& chpi = full_hash_cache_[prefix];
     chpi.full_hash_infos.clear();
@@ skipping 35 matching lines @@
     RecordV4GetHashCheckResult(GET_HASH_CHECK_MISS);
   }
 }
 
 // net::URLFetcherDelegate implementation ----------------------------------
 
 // SafeBrowsing request responses are handled here.
 void V4GetHashProtocolManager::OnURLFetchComplete(
     const net::URLFetcher* source) {
   DCHECK(CalledOnValidThread());
+  DCHECK_CURRENTLY_ON(BrowserThread::IO);
 
   PendingHashRequests::iterator it = pending_hash_requests_.find(source);
   DCHECK(it != pending_hash_requests_.end()) << "Request not found";
 
   int response_code = source->GetResponseCode();
   net::URLRequestStatus status = source->GetStatus();
   V4ProtocolManagerUtil::RecordHttpResponseOrErrorCode(
       kUmaV4HashResponseMetricName, status, response_code);
 
   std::vector<FullHashInfo> full_hash_infos;
@@ skipping 35 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