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

chrome/browser/safe_browsing/safe_browsing_database_unittest.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.
 //
 // Unit tests for the SafeBrowsing storage system.
 
 #include "base/file_util.h"
 #include "base/files/scoped_temp_dir.h"
 #include "base/logging.h"
 #include "base/message_loop/message_loop.h"
 #include "base/sha1.h"
 #include "base/time/time.h"
 #include "chrome/browser/safe_browsing/safe_browsing_database.h"
 #include "chrome/browser/safe_browsing/safe_browsing_store_file.h"
 #include "content/public/test/test_browser_thread_bundle.h"
 #include "crypto/sha2.h"
 #include "net/base/net_util.h"
 #include "sql/connection.h"
 #include "sql/statement.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "testing/platform_test.h"
 #include "url/gurl.h"
 
 using base::Time;
+using base::TimeDelta;
 
 namespace {
 
+TimeDelta kCacheLifetime = TimeDelta::FromMinutes(45);

[mattm, 2014/05/12 21:56:27]

const?

[Scott Hess - ex-Googler, 2014/05/12 23:10:48]

Sensible!

+
 SBPrefix SBPrefixForString(const std::string& str) {
   return SBFullHashForString(str).prefix;
 }
 
 std::string HashedIpPrefix(const std::string& ip_prefix, size_t prefix_size) {
   net::IPAddressNumber ip_number;
   EXPECT_TRUE(net::ParseIPLiteralToNumber(ip_prefix, &ip_number));
   EXPECT_EQ(net::kIPv6AddressSize, ip_number.size());
   const std::string hashed_ip_prefix = base::SHA1HashString(
       net::IPAddressToPackedString(ip_number));
@@ skipping 507 matching lines @@
   database_->InsertChunks(safe_browsing_util::kMalwareList, chunks);
 
   database_->UpdateFinished(true);
 
   // Make sure they were added correctly.
   GetListsInfo(&lists);
   EXPECT_TRUE(lists[0].name == safe_browsing_util::kMalwareList);
   EXPECT_EQ(lists[0].adds, "1-3,7");
   EXPECT_TRUE(lists[0].subs.empty());
 
-  const Time now = Time::Now();
   std::vector<SBFullHashResult> cached_hashes;
   std::vector<SBPrefix> prefix_hits;
   EXPECT_TRUE(database_->ContainsBrowseUrl(
-      GURL("http://www.evil.com/phishing.html"),
-      &prefix_hits, &cached_hashes, now));
+      GURL("http://www.evil.com/phishing.html"), &prefix_hits, &cached_hashes));
   EXPECT_EQ(prefix_hits[0], SBPrefixForString("www.evil.com/phishing.html"));
   EXPECT_EQ(prefix_hits.size(), 1U);
 
   EXPECT_TRUE(database_->ContainsBrowseUrl(
-      GURL("http://www.evil.com/malware.html"),
-      &prefix_hits, &cached_hashes, now));
+      GURL("http://www.evil.com/malware.html"), &prefix_hits, &cached_hashes));
 
   EXPECT_TRUE(database_->ContainsBrowseUrl(
-      GURL("http://www.evil.com/notevil1.html"),
-      &prefix_hits, &cached_hashes, now));
+      GURL("http://www.evil.com/notevil1.html"), &prefix_hits, &cached_hashes));
 
   EXPECT_TRUE(database_->ContainsBrowseUrl(
-      GURL("http://www.evil.com/notevil2.html"),
-      &prefix_hits, &cached_hashes, now));
+      GURL("http://www.evil.com/notevil2.html"), &prefix_hits, &cached_hashes));
 
   EXPECT_TRUE(database_->ContainsBrowseUrl(
-      GURL("http://www.good.com/good1.html"),
-      &prefix_hits, &cached_hashes, now));
+      GURL("http://www.good.com/good1.html"), &prefix_hits, &cached_hashes));
 
   EXPECT_TRUE(database_->ContainsBrowseUrl(
-      GURL("http://www.good.com/good2.html"),
-      &prefix_hits, &cached_hashes, now));
+      GURL("http://www.good.com/good2.html"), &prefix_hits, &cached_hashes));
 
   EXPECT_TRUE(database_->ContainsBrowseUrl(
-      GURL("http://192.168.0.1/malware.html"),
-      &prefix_hits, &cached_hashes, now));
+      GURL("http://192.168.0.1/malware.html"), &prefix_hits, &cached_hashes));
 
   EXPECT_FALSE(database_->ContainsBrowseUrl(
-      GURL("http://www.evil.com/"),
-      &prefix_hits, &cached_hashes, now));
+      GURL("http://www.evil.com/"), &prefix_hits, &cached_hashes));
   EXPECT_TRUE(prefix_hits.empty());
 
   EXPECT_FALSE(database_->ContainsBrowseUrl(
-      GURL("http://www.evil.com/robots.txt"),
-      &prefix_hits, &cached_hashes, now));
+      GURL("http://www.evil.com/robots.txt"), &prefix_hits, &cached_hashes));
 
   EXPECT_TRUE(database_->ContainsBrowseUrl(
-      GURL("http://www.evil.com/evil.html"),
-      &prefix_hits, &cached_hashes, now));
+      GURL("http://www.evil.com/evil.html"), &prefix_hits, &cached_hashes));
   ASSERT_EQ(1U, prefix_hits.size());
   EXPECT_EQ(prefix_hits[0], SBPrefixForString("www.evil.com/evil.html"));
 
   // Attempt to re-add the first chunk (should be a no-op).
   // see bug: http://code.google.com/p/chromium/issues/detail?id=4522
   chunk.hosts.clear();
   InsertAddChunkHost2PrefixUrls(&chunk, 1, "www.evil.com/",
                                 "www.evil.com/phishing.html",
                                 "www.evil.com/malware.html");
   chunks.clear();
@@ skipping 12 matching lines @@
   InsertSubChunkHostPrefixUrl(&chunk, 4, 2, "www.evil.com/",
                               "www.evil.com/notevil1.html");
   chunks.clear();
   chunks.push_back(chunk);
   EXPECT_TRUE(database_->UpdateStarted(&lists));
   database_->InsertChunks(safe_browsing_util::kMalwareList, chunks);
 
   database_->UpdateFinished(true);
 
   EXPECT_TRUE(database_->ContainsBrowseUrl(
-      GURL("http://www.evil.com/phishing.html"),
-      &prefix_hits, &cached_hashes, now));
+      GURL("http://www.evil.com/phishing.html"), &prefix_hits, &cached_hashes));
   EXPECT_EQ(prefix_hits[0], SBPrefixForString("www.evil.com/phishing.html"));
   EXPECT_EQ(prefix_hits.size(), 1U);
 
   EXPECT_FALSE(database_->ContainsBrowseUrl(
-      GURL("http://www.evil.com/notevil1.html"),
-      &prefix_hits, &cached_hashes, now));
+      GURL("http://www.evil.com/notevil1.html"), &prefix_hits, &cached_hashes));
   EXPECT_TRUE(prefix_hits.empty());
 
   EXPECT_TRUE(database_->ContainsBrowseUrl(
-      GURL("http://www.evil.com/notevil2.html"),
-      &prefix_hits, &cached_hashes, now));
+      GURL("http://www.evil.com/notevil2.html"), &prefix_hits, &cached_hashes));
 
   EXPECT_TRUE(database_->ContainsBrowseUrl(
-      GURL("http://www.good.com/good1.html"),
-      &prefix_hits, &cached_hashes, now));
+      GURL("http://www.good.com/good1.html"), &prefix_hits, &cached_hashes));
 
   EXPECT_TRUE(database_->ContainsBrowseUrl(
-      GURL("http://www.good.com/good2.html"),
-      &prefix_hits, &cached_hashes, now));
+      GURL("http://www.good.com/good2.html"), &prefix_hits, &cached_hashes));
 
   GetListsInfo(&lists);
   EXPECT_TRUE(lists[0].name == safe_browsing_util::kMalwareList);
   EXPECT_EQ(lists[0].subs, "4");
 
   // Test the same sub chunk again.  This should be a no-op.
   // see bug: http://code.google.com/p/chromium/issues/detail?id=4522
   chunk.hosts.clear();
   InsertSubChunkHostPrefixUrl(&chunk, 4, 2, "www.evil.com/",
                               "www.evil.com/notevil1.html");
   chunks.clear();
   chunks.push_back(chunk);
 
   EXPECT_TRUE(database_->UpdateStarted(&lists));
   database_->InsertChunks(safe_browsing_util::kMalwareList, chunks);
   database_->UpdateFinished(true);
 
   GetListsInfo(&lists);
   EXPECT_TRUE(lists[0].name == safe_browsing_util::kMalwareList);
   EXPECT_EQ(lists[0].subs, "4");
 
   // Test removing all the prefixes from an add chunk.
   EXPECT_TRUE(database_->UpdateStarted(&lists));
   AddDelChunk(safe_browsing_util::kMalwareList, 2);
   database_->UpdateFinished(true);
 
   EXPECT_FALSE(database_->ContainsBrowseUrl(
-      GURL("http://www.evil.com/notevil2.html"),
-      &prefix_hits, &cached_hashes, now));
+      GURL("http://www.evil.com/notevil2.html"), &prefix_hits, &cached_hashes));
 
   EXPECT_FALSE(database_->ContainsBrowseUrl(
-      GURL("http://www.good.com/good1.html"),
-      &prefix_hits, &cached_hashes, now));
+      GURL("http://www.good.com/good1.html"), &prefix_hits, &cached_hashes));
 
   EXPECT_FALSE(database_->ContainsBrowseUrl(
-      GURL("http://www.good.com/good2.html"),
-      &prefix_hits, &cached_hashes, now));
+      GURL("http://www.good.com/good2.html"), &prefix_hits, &cached_hashes));
 
   GetListsInfo(&lists);
   EXPECT_TRUE(lists[0].name == safe_browsing_util::kMalwareList);
   EXPECT_EQ(lists[0].adds, "1,3,7");
   EXPECT_EQ(lists[0].subs, "4");
 
   // The adddel command exposed a bug in the transaction code where any
   // transaction after it would fail.  Add a dummy entry and remove it to
   // make sure the transcation works fine.
   chunk.hosts.clear();
@@ skipping 24 matching lines @@
                                 "www.notevilanymore.com/index.html",
                                 "www.notevilanymore.com/good.html");
   chunks.clear();
   chunks.push_back(chunk);
   EXPECT_TRUE(database_->UpdateStarted(&lists));
   database_->InsertChunks(safe_browsing_util::kMalwareList, chunks);
   database_->UpdateFinished(true);
 
   EXPECT_FALSE(database_->ContainsBrowseUrl(
       GURL("http://www.notevilanymore.com/index.html"),
-      &prefix_hits, &cached_hashes, now));
+      &prefix_hits, &cached_hashes));
 
   // Now insert the tardy add chunk and we don't expect them to appear
   // in database because of the previous sub chunk.
   chunk.hosts.clear();
   InsertAddChunkHost2PrefixUrls(&chunk, 10, "www.notevilanymore.com/",
                                 "www.notevilanymore.com/index.html",
                                 "www.notevilanymore.com/good.html");
   chunks.clear();
   chunks.push_back(chunk);
   EXPECT_TRUE(database_->UpdateStarted(&lists));
   database_->InsertChunks(safe_browsing_util::kMalwareList, chunks);
   database_->UpdateFinished(true);
 
   EXPECT_FALSE(database_->ContainsBrowseUrl(
       GURL("http://www.notevilanymore.com/index.html"),
-      &prefix_hits, &cached_hashes, now));
+      &prefix_hits, &cached_hashes));
 
   EXPECT_FALSE(database_->ContainsBrowseUrl(
       GURL("http://www.notevilanymore.com/good.html"),
-      &prefix_hits, &cached_hashes, now));
+      &prefix_hits, &cached_hashes));
 
   // Reset and reload the database.  The database will rely on the prefix set.
   database_.reset(new SafeBrowsingDatabaseNew);
   database_->Init(database_filename_);
 
   // Check that a prefix still hits.
   EXPECT_TRUE(database_->ContainsBrowseUrl(
-      GURL("http://www.evil.com/phishing.html"),
-      &prefix_hits, &cached_hashes, now));
+      GURL("http://www.evil.com/phishing.html"), &prefix_hits, &cached_hashes));
   EXPECT_EQ(prefix_hits[0], SBPrefixForString("www.evil.com/phishing.html"));
   EXPECT_EQ(prefix_hits.size(), 1U);
 
   // Also check that it's not just always returning true in this case.
   EXPECT_FALSE(database_->ContainsBrowseUrl(
-      GURL("http://www.evil.com/"),
-      &prefix_hits, &cached_hashes, now));
+      GURL("http://www.evil.com/"), &prefix_hits, &cached_hashes));
 
   // Check that the full hash is still present.
   EXPECT_TRUE(database_->ContainsBrowseUrl(
-      GURL("http://www.evil.com/evil.html"),
-      &prefix_hits, &cached_hashes, now));
+      GURL("http://www.evil.com/evil.html"), &prefix_hits, &cached_hashes));
   ASSERT_EQ(1U, prefix_hits.size());
   EXPECT_EQ(prefix_hits[0], SBPrefixForString("www.evil.com/evil.html"));
 }
 
 
 // Test adding zero length chunks to the database.
 TEST_F(SafeBrowsingDatabaseTest, ZeroSizeChunk) {
   SBChunkList chunks;
   SBChunk chunk;
 
@@ skipping 52 matching lines @@
 
   empty_chunk.hosts.clear();
   InsertAddChunkHostPrefixUrl(&empty_chunk, 22, "www.notempy.com/",
                               "www.notempty.com/full2.html");
   chunks.push_back(empty_chunk);
 
   EXPECT_TRUE(database_->UpdateStarted(&lists));
   database_->InsertChunks(safe_browsing_util::kMalwareList, chunks);
   database_->UpdateFinished(true);
 
-  const Time now = Time::Now();
   std::vector<SBFullHashResult> cached_hashes;
   std::vector<SBPrefix> prefix_hits;
   EXPECT_TRUE(database_->ContainsBrowseUrl(
       GURL("http://www.notempty.com/full1.html"),
-      &prefix_hits, &cached_hashes, now));
+      &prefix_hits, &cached_hashes));
   EXPECT_TRUE(database_->ContainsBrowseUrl(
       GURL("http://www.notempty.com/full2.html"),
-      &prefix_hits, &cached_hashes, now));
+      &prefix_hits, &cached_hashes));
 
   GetListsInfo(&lists);
   EXPECT_EQ(lists[0].adds, "1,10,19-22");
   EXPECT_EQ(lists[0].subs, "7");
 
   // Handle AddDel and SubDel commands for empty chunks.
   EXPECT_TRUE(database_->UpdateStarted(&lists));
   AddDelChunk(safe_browsing_util::kMalwareList, 21);
   database_->UpdateFinished(true);
 
@@ skipping 30 matching lines @@
   full_hash.hash = SBFullHashForString("www.evil.com/phishing.html");
   full_hash.list_id = safe_browsing_util::MALWARE;
 
   std::vector<SBFullHashResult> results;
   results.push_back(full_hash);
 
   full_hash.hash = SBFullHashForString("www.evil.com/malware.html");
   results.push_back(full_hash);
 
   std::vector<SBPrefix> prefixes;
-  database_->CacheHashResults(prefixes, results);
+  database_->CacheHashResults(prefixes, results, kCacheLifetime);
 }
 
 TEST_F(SafeBrowsingDatabaseTest, HashCaching) {
   PopulateDatabaseForCacheTest();
 
   // We should have both full hashes in the cache.
   EXPECT_EQ(2U, database_->cached_browse_hashes_.size());
 
   // Test the cache lookup for the first prefix.
   std::vector<SBPrefix> prefixes;
   std::vector<SBFullHashResult> cached_hashes;
   database_->ContainsBrowseUrl(
-      GURL("http://www.evil.com/phishing.html"),
-      &prefixes, &cached_hashes, Time::Now());
+      GURL("http://www.evil.com/phishing.html"), &prefixes, &cached_hashes);
   ASSERT_EQ(1U, cached_hashes.size());
   EXPECT_TRUE(
       SBFullHashEqual(cached_hashes[0].hash,
                       SBFullHashForString("www.evil.com/phishing.html")));
 
   prefixes.clear();
   cached_hashes.clear();
 
   // Test the cache lookup for the second prefix.
   database_->ContainsBrowseUrl(
-      GURL("http://www.evil.com/malware.html"),
-      &prefixes, &cached_hashes, Time::Now());
+      GURL("http://www.evil.com/malware.html"), &prefixes, &cached_hashes);
   ASSERT_EQ(1U, cached_hashes.size());
   EXPECT_TRUE(
       SBFullHashEqual(cached_hashes[0].hash,
                       SBFullHashForString("www.evil.com/malware.html")));
 
   prefixes.clear();
   cached_hashes.clear();
 
   // Test removing a prefix via a sub chunk.
   SBChunk chunk;
   SBChunkList chunks;
   InsertSubChunkHostPrefixUrl(&chunk, 2, 1, "www.evil.com/",
                               "www.evil.com/phishing.html");
   chunks.push_back(chunk);
 
   std::vector<SBListChunkRanges> lists;
   EXPECT_TRUE(database_->UpdateStarted(&lists));
   database_->InsertChunks(safe_browsing_util::kMalwareList, chunks);
   database_->UpdateFinished(true);
 
   // This prefix should still be there, but the fullhash is gone.
   EXPECT_TRUE(database_->ContainsBrowseUrl(
-      GURL("http://www.evil.com/malware.html"),
-      &prefixes, &cached_hashes, Time::Now()));
+      GURL("http://www.evil.com/malware.html"), &prefixes, &cached_hashes));
   ASSERT_EQ(1U, prefixes.size());
   EXPECT_EQ(SBPrefixForString("www.evil.com/malware.html"), prefixes[0]);
   EXPECT_TRUE(cached_hashes.empty());
   prefixes.clear();
   cached_hashes.clear();
 
   // This prefix should be gone.
   database_->ContainsBrowseUrl(
-      GURL("http://www.evil.com/phishing.html"),
-      &prefixes, &cached_hashes, Time::Now());
+      GURL("http://www.evil.com/phishing.html"), &prefixes, &cached_hashes);
   EXPECT_TRUE(cached_hashes.empty());
 
   prefixes.clear();
   cached_hashes.clear();
 
   // Test that an AddDel for the original chunk removes the last cached entry.
   EXPECT_TRUE(database_->UpdateStarted(&lists));
   AddDelChunk(safe_browsing_util::kMalwareList, 1);
   database_->UpdateFinished(true);
   database_->ContainsBrowseUrl(
-      GURL("http://www.evil.com/malware.html"),
-      &prefixes, &cached_hashes, Time::Now());
+      GURL("http://www.evil.com/malware.html"), &prefixes, &cached_hashes);
   EXPECT_TRUE(cached_hashes.empty());
   EXPECT_TRUE(database_->cached_browse_hashes_.empty());
 
   prefixes.clear();
   cached_hashes.clear();
 
   // Test that the cache won't return expired values. First we have to adjust
   // the cached entries' received time to make them older, since the database
   // cache insert uses Time::Now(). First, store some entries.
   PopulateDatabaseForCacheTest();
 
   std::vector<SBFullHashCached>* hash_cache = &database_->cached_browse_hashes_;
   EXPECT_EQ(2U, hash_cache->size());
 
-  // Now adjust one of the entries times to be in the past.
-  base::Time expired = base::Time::Now() - base::TimeDelta::FromMinutes(60);
+  // Now adjust one of the entries times to be expired.
+  const Time expired = Time::Now() - TimeDelta::FromMinutes(1);
   const SBPrefix key = SBPrefixForString("www.evil.com/malware.html");
   std::vector<SBFullHashCached>::iterator iter;
   for (iter = hash_cache->begin(); iter != hash_cache->end(); ++iter) {
     if (iter->hash.prefix == key) {
-      iter->received = static_cast<int32>(expired.ToTimeT());
+      iter->expire_after = expired;
       break;
     }
   }
   EXPECT_TRUE(iter != hash_cache->end());
 
   database_->ContainsBrowseUrl(
-      GURL("http://www.evil.com/malware.html"),
-      &prefixes, &cached_hashes, expired);
+      GURL("http://www.evil.com/malware.html"), &prefixes, &cached_hashes);
   EXPECT_TRUE(cached_hashes.empty());
 
   // This entry should still exist.
   database_->ContainsBrowseUrl(
-      GURL("http://www.evil.com/phishing.html"),
-      &prefixes, &cached_hashes, expired);
+      GURL("http://www.evil.com/phishing.html"), &prefixes, &cached_hashes);
   EXPECT_EQ(1U, cached_hashes.size());
 
   // Testing prefix miss caching. First, we clear out the existing database,
   // Since PopulateDatabaseForCacheTest() doesn't handle adding duplicate
   // chunks.
   EXPECT_TRUE(database_->UpdateStarted(&lists));
   AddDelChunk(safe_browsing_util::kMalwareList, 1);
   database_->UpdateFinished(true);
 
   std::vector<SBPrefix> prefix_misses;
   std::vector<SBFullHashResult> empty_full_hash;
   prefix_misses.push_back(SBPrefixForString("http://www.bad.com/malware.html"));
   prefix_misses.push_back(
       SBPrefixForString("http://www.bad.com/phishing.html"));
-  database_->CacheHashResults(prefix_misses, empty_full_hash);
+  database_->CacheHashResults(prefix_misses, empty_full_hash, kCacheLifetime);
 
   // Prefixes with no full results are misses.
   EXPECT_EQ(2U, database_->prefix_miss_cache_.size());
 
   // Update the database.
   PopulateDatabaseForCacheTest();
 
   // Prefix miss cache should be cleared.
   EXPECT_TRUE(database_->prefix_miss_cache_.empty());
 
   // Cache a GetHash miss for a particular prefix, and even though the prefix is
   // in the database, it is flagged as a miss so looking up the associated URL
   // will not succeed.
   prefixes.clear();
   cached_hashes.clear();
   prefix_misses.clear();
   empty_full_hash.clear();
   prefix_misses.push_back(SBPrefixForString("www.evil.com/phishing.html"));
-  database_->CacheHashResults(prefix_misses, empty_full_hash);
+  database_->CacheHashResults(prefix_misses, empty_full_hash, kCacheLifetime);
   EXPECT_FALSE(database_->ContainsBrowseUrl(
-      GURL("http://www.evil.com/phishing.html"),
-      &prefixes, &cached_hashes, Time::Now()));
+      GURL("http://www.evil.com/phishing.html"), &prefixes, &cached_hashes));
 
   prefixes.clear();
   cached_hashes.clear();
 
   // Test receiving a full add chunk.
   chunk.hosts.clear();
   InsertAddChunkHost2FullHashes(&chunk, 20, "www.fullevil.com/",
                                 "www.fullevil.com/bad1.html",
                                 "www.fullevil.com/bad2.html");
   chunks.clear();
   chunks.push_back(chunk);
   EXPECT_TRUE(database_->UpdateStarted(&lists));
   database_->InsertChunks(safe_browsing_util::kMalwareList, chunks);
   database_->UpdateFinished(true);
 
   EXPECT_TRUE(database_->ContainsBrowseUrl(
-      GURL("http://www.fullevil.com/bad1.html"),
-      &prefixes, &cached_hashes, Time::Now()));
+      GURL("http://www.fullevil.com/bad1.html"), &prefixes, &cached_hashes));
   EXPECT_TRUE(cached_hashes.empty());
   ASSERT_EQ(1U, prefixes.size());
   EXPECT_EQ(SBPrefixForString("www.fullevil.com/bad1.html"), prefixes[0]);
   prefixes.clear();
   cached_hashes.clear();
 
   EXPECT_TRUE(database_->ContainsBrowseUrl(
-      GURL("http://www.fullevil.com/bad2.html"),
-      &prefixes, &cached_hashes, Time::Now()));
+      GURL("http://www.fullevil.com/bad2.html"), &prefixes, &cached_hashes));
   EXPECT_TRUE(cached_hashes.empty());
   ASSERT_EQ(1U, prefixes.size());
   EXPECT_EQ(SBPrefixForString("www.fullevil.com/bad2.html"), prefixes[0]);
   prefixes.clear();
   cached_hashes.clear();
 
   // Test receiving a full sub chunk, which will remove one of the full adds.
   chunk.hosts.clear();
   InsertSubChunkHostFullHash(&chunk, 200, 20,
                              "www.fullevil.com/",
                              "www.fullevil.com/bad1.html");
   chunks.clear();
   chunks.push_back(chunk);
   EXPECT_TRUE(database_->UpdateStarted(&lists));
   database_->InsertChunks(safe_browsing_util::kMalwareList, chunks);
   database_->UpdateFinished(true);
 
   EXPECT_FALSE(database_->ContainsBrowseUrl(
-      GURL("http://www.fullevil.com/bad1.html"),
-      &prefixes, &cached_hashes, Time::Now()));
+      GURL("http://www.fullevil.com/bad1.html"), &prefixes, &cached_hashes));
   EXPECT_TRUE(cached_hashes.empty());
 
   // There should be one remaining full add.
   EXPECT_TRUE(database_->ContainsBrowseUrl(
-      GURL("http://www.fullevil.com/bad2.html"),
-      &prefixes, &cached_hashes, Time::Now()));
+      GURL("http://www.fullevil.com/bad2.html"), &prefixes, &cached_hashes));
   EXPECT_TRUE(cached_hashes.empty());
   ASSERT_EQ(1U, prefixes.size());
   EXPECT_EQ(SBPrefixForString("www.fullevil.com/bad2.html"), prefixes[0]);
   prefixes.clear();
   cached_hashes.clear();
 
   // Now test an AddDel for the remaining full add.
   EXPECT_TRUE(database_->UpdateStarted(&lists));
   AddDelChunk(safe_browsing_util::kMalwareList, 20);
   database_->UpdateFinished(true);
 
   EXPECT_FALSE(database_->ContainsBrowseUrl(
-      GURL("http://www.fullevil.com/bad1.html"),
-      &prefixes, &cached_hashes, Time::Now()));
+      GURL("http://www.fullevil.com/bad1.html"), &prefixes, &cached_hashes));
   EXPECT_FALSE(database_->ContainsBrowseUrl(
-      GURL("http://www.fullevil.com/bad2.html"),
-      &prefixes, &cached_hashes, Time::Now()));
+      GURL("http://www.fullevil.com/bad2.html"), &prefixes, &cached_hashes));
 
   // Add a fullhash which has a prefix collision for a known url.
   static const char kExampleFine[] = "www.example.com/fine.html";
   static const char kExampleCollision[] =
       "www.example.com/3123364814/malware.htm";
   ASSERT_EQ(SBPrefixForString(kExampleFine),
             SBPrefixForString(kExampleCollision));
   EXPECT_TRUE(database_->UpdateStarted(&lists));
   {
     SBChunkList chunks;
     SBChunk chunk;
     InsertAddChunkHostPrefixUrl(&chunk, 21, "www.example.com/",
                                 kExampleCollision);
     chunks.push_back(chunk);
     database_->InsertChunks(safe_browsing_util::kMalwareList, chunks);
   }
   database_->UpdateFinished(true);
 
   // Cache gethash response for |kExampleCollision|.
   {
     SBFullHashResult result;
     result.hash = SBFullHashForString(kExampleCollision);
     result.list_id = safe_browsing_util::MALWARE;
     database_->CacheHashResults(std::vector<SBPrefix>(1, result.hash.prefix),
-                                std::vector<SBFullHashResult>(1, result));
+                                std::vector<SBFullHashResult>(1, result),
+                                kCacheLifetime);
   }
 
   // Expect a prefix hit due to the collision between |kExampleFine| and
   // |kExampleCollision|, with the gethash showing only |kExampleCollision|.
   EXPECT_TRUE(database_->ContainsBrowseUrl(
-      GURL(std::string("http://") + kExampleFine),
-      &prefixes, &cached_hashes, Time::Now()));
+      GURL(std::string("http://") + kExampleFine), &prefixes, &cached_hashes));
   ASSERT_EQ(1U, prefixes.size());
   EXPECT_EQ(SBPrefixForString(kExampleFine), prefixes[0]);
   ASSERT_EQ(1U, cached_hashes.size());
   EXPECT_TRUE(SBFullHashEqual(cached_hashes[0].hash,
                               SBFullHashForString(kExampleCollision)));
 }
 
 // Test that corrupt databases are appropriately handled, even if the
 // corruption is detected in the midst of the update.
 // TODO(shess): Disabled until ScopedLogMessageIgnorer resolved.
@@ skipping 430 matching lines @@
   EXPECT_TRUE(database_->UpdateStarted(&lists));
   database_->InsertChunks(safe_browsing_util::kPhishingList, chunks);
   database_->UpdateFinished(true);
 
   GetListsInfo(&lists);
   EXPECT_EQ(std::string(safe_browsing_util::kMalwareList), lists[0].name);
   EXPECT_EQ("1", lists[0].adds);
   EXPECT_EQ(std::string(safe_browsing_util::kPhishingList), lists[1].name);
   EXPECT_EQ("47", lists[1].adds);
 
-  const Time now = Time::Now();
   std::vector<SBPrefix> prefixes;
   std::vector<SBFullHashResult> cached_hashes;
   std::vector<SBPrefix> prefix_hits;
 
   EXPECT_TRUE(database_->ContainsBrowseUrl(
-      GURL("http://www.evil.com/malware1.html"),
-      &prefixes, &cached_hashes, now));
+      GURL("http://www.evil.com/malware1.html"), &prefixes, &cached_hashes));
   EXPECT_TRUE(database_->ContainsBrowseUrl(
-      GURL("http://www.evil.com/malware2.html"),
-      &prefixes, &cached_hashes, now));
+      GURL("http://www.evil.com/malware2.html"), &prefixes, &cached_hashes));
   EXPECT_TRUE(database_->ContainsBrowseUrl(
-      GURL("http://www.evil.com/phishing1.html"),
-      &prefixes, &cached_hashes, now));
+      GURL("http://www.evil.com/phishing1.html"), &prefixes, &cached_hashes));
   EXPECT_TRUE(database_->ContainsBrowseUrl(
-      GURL("http://www.evil.com/phishing2.html"),
-      &prefixes, &cached_hashes, now));
+      GURL("http://www.evil.com/phishing2.html"), &prefixes, &cached_hashes));
 
   // Test removing a single prefix from the add chunk.
   // Remove the prefix that added first.
   chunk.hosts.clear();
   InsertSubChunkHostPrefixUrl(&chunk, 4, 1, "www.evil.com/",
                               "www.evil.com/malware1.html");
   chunks.clear();
   chunks.push_back(chunk);
   EXPECT_TRUE(database_->UpdateStarted(&lists));
   database_->InsertChunks(safe_browsing_util::kMalwareList, chunks);
   database_->UpdateFinished(true);
 
   // Remove the prefix that added last.
   chunk.hosts.clear();
   InsertSubChunkHostPrefixUrl(&chunk, 5, 47, "www.evil.com/",
                               "www.evil.com/phishing2.html");
   chunks.clear();
   chunks.push_back(chunk);
   EXPECT_TRUE(database_->UpdateStarted(&lists));
   database_->InsertChunks(safe_browsing_util::kPhishingList, chunks);
   database_->UpdateFinished(true);
 
   // Verify that the database contains urls expected.
   EXPECT_FALSE(database_->ContainsBrowseUrl(
-      GURL("http://www.evil.com/malware1.html"),
-      &prefixes, &cached_hashes, now));
+      GURL("http://www.evil.com/malware1.html"), &prefixes, &cached_hashes));
   EXPECT_TRUE(database_->ContainsBrowseUrl(
-      GURL("http://www.evil.com/malware2.html"),
-      &prefixes, &cached_hashes, now));
+      GURL("http://www.evil.com/malware2.html"), &prefixes, &cached_hashes));
   EXPECT_TRUE(database_->ContainsBrowseUrl(
-      GURL("http://www.evil.com/phishing1.html"),
-      &prefixes, &cached_hashes, now));
+      GURL("http://www.evil.com/phishing1.html"), &prefixes, &cached_hashes));
   EXPECT_FALSE(database_->ContainsBrowseUrl(
-      GURL("http://www.evil.com/phishing2.html"),
-      &prefixes, &cached_hashes, now));
+      GURL("http://www.evil.com/phishing2.html"), &prefixes, &cached_hashes));
 }
 
 // Test that an empty update doesn't actually update the database.
 // This isn't a functionality requirement, but it is a useful
 // optimization.
 TEST_F(SafeBrowsingDatabaseTest, EmptyUpdate) {
   SBChunkList chunks;
   SBChunk chunk;
 
   base::FilePath filename = database_->BrowseDBFilename(database_filename_);
 
   // Prime the database.
   std::vector<SBListChunkRanges> lists;
   EXPECT_TRUE(database_->UpdateStarted(&lists));
 
   InsertAddChunkHostPrefixUrl(&chunk, 1, "www.evil.com/",
                               "www.evil.com/malware.html");
   chunks.clear();
   chunks.push_back(chunk);
   database_->InsertChunks(safe_browsing_util::kMalwareList, chunks);
   database_->UpdateFinished(true);
 
   // Get an older time to reset the lastmod time for detecting whether
   // the file has been updated.
   base::File::Info before_info, after_info;
   ASSERT_TRUE(base::GetFileInfo(filename, &before_info));
-  const base::Time old_last_modified =
-      before_info.last_modified - base::TimeDelta::FromSeconds(10);
+  const Time old_last_modified =
+      before_info.last_modified - TimeDelta::FromSeconds(10);
 
   // Inserting another chunk updates the database file.  The sleep is
   // needed because otherwise the entire test can finish w/in the
   // resolution of the lastmod time.
   ASSERT_TRUE(base::TouchFile(filename, old_last_modified, old_last_modified));
   ASSERT_TRUE(base::GetFileInfo(filename, &before_info));
   EXPECT_TRUE(database_->UpdateStarted(&lists));
   chunk.hosts.clear();
   InsertAddChunkHostPrefixUrl(&chunk, 2, "www.foo.com/",
                               "www.foo.com/malware.html");
@@ skipping 37 matching lines @@
 
     InsertAddChunkHostPrefixUrl(&chunk, 1, "www.evil.com/",
                                 "www.evil.com/malware.html");
     chunks.clear();
     chunks.push_back(chunk);
     database_->InsertChunks(safe_browsing_util::kMalwareList, chunks);
     database_->UpdateFinished(true);
   }
 
   // Find the malware url in the database, don't find a good url.
-  const Time now = Time::Now();
   std::vector<SBFullHashResult> cached_hashes;
   std::vector<SBPrefix> prefix_hits;
   EXPECT_TRUE(database_->ContainsBrowseUrl(
-      GURL("http://www.evil.com/malware.html"),
-      &prefix_hits, &cached_hashes, now));
+      GURL("http://www.evil.com/malware.html"), &prefix_hits, &cached_hashes));
   EXPECT_FALSE(database_->ContainsBrowseUrl(
-      GURL("http://www.good.com/goodware.html"),
-      &prefix_hits, &cached_hashes, now));
+      GURL("http://www.good.com/goodware.html"), &prefix_hits, &cached_hashes));
 
   base::FilePath filter_file = database_->PrefixSetForFilename(
       database_->BrowseDBFilename(database_filename_));
 
   // After re-creating the database, it should have a filter read from
   // a file, so it should find the same results.
   ASSERT_TRUE(base::PathExists(filter_file));
   database_.reset(new SafeBrowsingDatabaseNew);
   database_->Init(database_filename_);
   EXPECT_TRUE(database_->ContainsBrowseUrl(
-      GURL("http://www.evil.com/malware.html"),
-      &prefix_hits, &cached_hashes, now));
+      GURL("http://www.evil.com/malware.html"), &prefix_hits, &cached_hashes));
   EXPECT_FALSE(database_->ContainsBrowseUrl(
-      GURL("http://www.good.com/goodware.html"),
-      &prefix_hits, &cached_hashes, now));
+      GURL("http://www.good.com/goodware.html"), &prefix_hits, &cached_hashes));
 
   // If there is no filter file, the database cannot find malware urls.
   base::DeleteFile(filter_file, false);
   ASSERT_FALSE(base::PathExists(filter_file));
   database_.reset(new SafeBrowsingDatabaseNew);
   database_->Init(database_filename_);
   EXPECT_FALSE(database_->ContainsBrowseUrl(
-      GURL("http://www.evil.com/malware.html"),
-      &prefix_hits, &cached_hashes, now));
+      GURL("http://www.evil.com/malware.html"), &prefix_hits, &cached_hashes));
   EXPECT_FALSE(database_->ContainsBrowseUrl(
-      GURL("http://www.good.com/goodware.html"),
-      &prefix_hits, &cached_hashes, now));
+      GURL("http://www.good.com/goodware.html"), &prefix_hits, &cached_hashes));
 }
 
 TEST_F(SafeBrowsingDatabaseTest, MalwareIpBlacklist) {
   database_.reset();
   SafeBrowsingStoreFile* browse_store = new SafeBrowsingStoreFile();
   SafeBrowsingStoreFile* ip_blacklist_store = new SafeBrowsingStoreFile();
   database_.reset(new SafeBrowsingDatabaseNew(browse_store,
                                               NULL,
                                               NULL,
                                               NULL,
@@ skipping 121 matching lines @@
     SBChunkList chunks;
     SBChunk chunk;
     InsertAddChunkHostFullHashes(&chunk, 3, "www.example.com/",
                                  kExampleCollision);
     chunks.push_back(chunk);
     database_->InsertChunks(safe_browsing_util::kMalwareList, chunks);
   }
 
   database_->UpdateFinished(true);
 
-  const Time now = Time::Now();
   std::vector<SBFullHashResult> cached_hashes;
   std::vector<SBPrefix> prefix_hits;
 
   // Anything will hit the host prefix.
   EXPECT_TRUE(database_->ContainsBrowseUrl(
-      GURL("http://www.evil.com/malware.html"),
-      &prefix_hits, &cached_hashes, now));
+      GURL("http://www.evil.com/malware.html"), &prefix_hits, &cached_hashes));
   ASSERT_EQ(1U, prefix_hits.size());
   EXPECT_EQ(SBPrefixForString("www.evil.com/"), prefix_hits[0]);
   EXPECT_TRUE(cached_hashes.empty());
 
   // Hit the specific URL prefix.
   EXPECT_TRUE(database_->ContainsBrowseUrl(
       GURL(std::string("http://") + kWhateverMalware),
-      &prefix_hits, &cached_hashes, now));
+      &prefix_hits, &cached_hashes));
   ASSERT_EQ(1U, prefix_hits.size());
   EXPECT_EQ(SBPrefixForString(kWhateverMalware), prefix_hits[0]);
   EXPECT_TRUE(cached_hashes.empty());
 
   // Other URLs at that host are fine.
   EXPECT_FALSE(database_->ContainsBrowseUrl(
-      GURL("http://www.whatever.com/fine.html"),
-      &prefix_hits, &cached_hashes, now));
+      GURL("http://www.whatever.com/fine.html"), &prefix_hits, &cached_hashes));
   EXPECT_TRUE(prefix_hits.empty());
   EXPECT_TRUE(cached_hashes.empty());
 
   // Hit the specific URL full hash.
   EXPECT_TRUE(database_->ContainsBrowseUrl(
       GURL(std::string("http://") + kExampleCollision),
-      &prefix_hits, &cached_hashes, now));
+      &prefix_hits, &cached_hashes));
   ASSERT_EQ(1U, prefix_hits.size());
   EXPECT_EQ(SBPrefixForString(kExampleCollision), prefix_hits[0]);
   EXPECT_TRUE(cached_hashes.empty());
 
   // This prefix collides, but no full hash match.
   EXPECT_FALSE(database_->ContainsBrowseUrl(
       GURL(std::string("http://") + kExampleFine),
-      &prefix_hits, &cached_hashes, now));
+      &prefix_hits, &cached_hashes));
 }