Safebrowsing: change gethash caching to match api 2.3 rules, fix some corner cases.

chrome/browser/safe_browsing/database_manager.cc

 // Copyright (c) 2012 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 "chrome/browser/safe_browsing/database_manager.h"
 
 #include <algorithm>
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
@@ skipping 318 matching lines @@
   if (!MakeDatabaseAvailable()) {
     QueuedCheck queued_check(safe_browsing_util::MALWARE,  // or PHISH
                              client,
                              url,
                              expected_threats,
                              start);
     queued_checks_.push_back(queued_check);
     return false;
   }
 
-  std::string list;
   std::vector<SBPrefix> prefix_hits;
-  std::vector<SBFullHashResult> full_hits;
+  std::vector<SBFullHashResult> cache_hits;
 
   bool prefix_match =
-      database_->ContainsBrowseUrl(url, &list, &prefix_hits, &full_hits,
-          sb_service_->protocol_manager()->last_update());
+      database_->ContainsBrowseUrl(url, &prefix_hits, &cache_hits);
 
   UMA_HISTOGRAM_TIMES("SB2.FilterCheck", base::TimeTicks::Now() - start);
 
   if (!prefix_match)
     return true;  // URL is okay.
 
   // Needs to be asynchronous, since we could be in the constructor of a
   // ResourceDispatcherHost event handler which can't pause there.
   SafeBrowsingCheck* check = new SafeBrowsingCheck(std::vector<GURL>(1, url),
                                                    std::vector<SBFullHash>(),
                                                    client,
                                                    safe_browsing_util::MALWARE,
                                                    expected_threats);
-  check->need_get_hash = full_hits.empty();
+  check->need_get_hash = cache_hits.empty();
   check->prefix_hits.swap(prefix_hits);
-  check->full_hits.swap(full_hits);
+  check->cache_hits.swap(cache_hits);
   checks_.insert(check);
 
   BrowserThread::PostTask(
       BrowserThread::IO, FROM_HERE,
       base::Bind(&SafeBrowsingDatabaseManager::OnCheckDone, this, check));
 
   return false;
 }
 
 void SafeBrowsingDatabaseManager::CancelCheck(Client* client) {
@@ skipping 15 matching lines @@
     if (it->client == client)
       it = queued_checks_.erase(it);
     else
       ++it;
   }
 }
 
 void SafeBrowsingDatabaseManager::HandleGetHashResults(
     SafeBrowsingCheck* check,
     const std::vector<SBFullHashResult>& full_hashes,
-    bool can_cache) {
+    const base::TimeDelta& cache_lifetime) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
 
   if (!enabled_)
     return;
 
   // If the service has been shut down, |check| should have been deleted.
   DCHECK(checks_.find(check) != checks_.end());
 
   // |start| is set before calling |GetFullHash()|, which should be
   // the only path which gets to here.
   DCHECK(!check->start.is_null());
   UMA_HISTOGRAM_LONG_TIMES("SB2.Network",
                            base::TimeTicks::Now() - check->start);
 
   std::vector<SBPrefix> prefixes = check->prefix_hits;
   OnHandleGetHashResults(check, full_hashes);  // 'check' is deleted here.
 
-  if (can_cache && MakeDatabaseAvailable()) {
+  if (cache_lifetime != base::TimeDelta() && MakeDatabaseAvailable()) {
     // Cache the GetHash results in memory:
-    database_->CacheHashResults(prefixes, full_hashes);
+    database_->CacheHashResults(prefixes, full_hashes, cache_lifetime);
   }
 }
 
 void SafeBrowsingDatabaseManager::GetChunks(GetChunksCallback callback) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
   DCHECK(enabled_);
   DCHECK(!callback.is_null());
   safe_browsing_thread_->message_loop()->PostTask(FROM_HERE, base::Bind(
       &SafeBrowsingDatabaseManager::GetAllChunksFromDatabase, this, callback));
 }
@@ skipping 252 matching lines @@
     bool is_download = check->check_type == safe_browsing_util::BINURL;
     sb_service_->protocol_manager()->GetFullHash(
         check->prefix_hits,
         base::Bind(&SafeBrowsingDatabaseManager::HandleGetHashResults,
                    base::Unretained(this),
                    check),
         is_download);
   } else {
     // We may have cached results for previous GetHash queries.  Since
     // this data comes from cache, don't histogram hits.
-    HandleOneCheck(check, check->full_hits);
+    bool is_threat = HandleOneCheck(check, check->cache_hits);
+    // cache_hits should only contain hits for a fullhash we searched for, so if
+    // we got to this point it should always result in a threat match.
+    DCHECK(is_threat);
   }
 }
 
 void SafeBrowsingDatabaseManager::GetAllChunksFromDatabase(
     GetChunksCallback callback) {
   DCHECK_EQ(base::MessageLoop::current(),
             safe_browsing_thread_->message_loop());
 
   bool database_error = true;
   std::vector<SBListChunkRanges> lists;
@@ skipping 136 matching lines @@
   closing_database_ = false;
 }
 
 void SafeBrowsingDatabaseManager::OnResetDatabase() {
   DCHECK_EQ(base::MessageLoop::current(),
             safe_browsing_thread_->message_loop());
   GetDatabase()->ResetDatabase();
 }
 
 void SafeBrowsingDatabaseManager::CacheHashResults(
-  const std::vector<SBPrefix>& prefixes,
-  const std::vector<SBFullHashResult>& full_hashes) {
+    const std::vector<SBPrefix>& prefixes,
+    const std::vector<SBFullHashResult>& full_hashes,
+    const base::TimeDelta& cache_lifetime) {
   DCHECK_EQ(base::MessageLoop::current(),
             safe_browsing_thread_->message_loop());
-  GetDatabase()->CacheHashResults(prefixes, full_hashes);
+  GetDatabase()->CacheHashResults(prefixes, full_hashes, cache_lifetime);
 }
 
 void SafeBrowsingDatabaseManager::OnHandleGetHashResults(
     SafeBrowsingCheck* check,
     const std::vector<SBFullHashResult>& full_hashes) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
   safe_browsing_util::ListType check_type = check->check_type;
   SBPrefix prefix = check->prefix_hits[0];
   GetHashRequests::iterator it = gethash_requests_.find(prefix);
   if (check->prefix_hits.size() > 1 || it == gethash_requests_.end()) {
@@ skipping 153 matching lines @@
       new base::WeakPtrFactory<SafeBrowsingDatabaseManager>(this));
   checks_.insert(check);
 
   safe_browsing_thread_->message_loop()->PostTask(FROM_HERE, task);
 
   base::MessageLoop::current()->PostDelayedTask(FROM_HERE,
       base::Bind(&SafeBrowsingDatabaseManager::TimeoutCallback,
                  check->timeout_factory_->GetWeakPtr(), check),
       check_timeout_);
 }