[safe browsing] Switch to independent cache lifetimes for gethash items.

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 344 matching lines @@
                              expected_threats,
                              start);
     queued_checks_.push_back(queued_check);
     return false;
   }
 
   std::vector<SBPrefix> prefix_hits;
   std::vector<SBFullHashResult> cached_hits;
 
   bool prefix_match =
-      database_->ContainsBrowseUrl(url, &prefix_hits, &cached_hits,
-          sb_service_->protocol_manager()->last_update());
+      database_->ContainsBrowseUrl(url, &prefix_hits, &cached_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>(),
@@ skipping 31 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()) {
-    // Cache the GetHash results in memory:
-    database_->CacheHashResults(prefixes, full_hashes);
-  }
+  // Cache the GetHash results.
+  if (cache_lifetime != base::TimeDelta() && MakeDatabaseAvailable())
+    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 385 matching lines @@
   base::AutoLock lock(database_lock_);
   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) {
-  DCHECK_EQ(base::MessageLoop::current(),
-            safe_browsing_thread_->message_loop());
-  GetDatabase()->CacheHashResults(prefixes, full_hashes);
-}
-
 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()) {
     const bool hit = HandleOneCheck(check, full_hashes);
     RecordGetHashCheckStatus(hit, check_type, full_hashes);
@@ skipping 151 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_);
 }