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

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 "chrome/browser/safe_browsing/safe_browsing_database.h"
+
 #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;
 
 namespace {
 
 SBPrefix SBPrefixForString(const std::string& str) {
   return SBFullHashForString(str).prefix;
 }
 
+SBFullHash SBFullHashForPrefixAndSuffix(SBPrefix prefix, std::string suffix) {
+  SBFullHash full_hash;
+  memset(&full_hash, 0, sizeof(SBFullHash));
+  full_hash.prefix = prefix;
+  CHECK_LE(suffix.size() + sizeof(SBPrefix), sizeof(SBFullHash));
+  memcpy(full_hash.full_hash + sizeof(SBPrefix), suffix.data(), suffix.size());
+  return full_hash;
+}
+
 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));
   std::string hash(crypto::kSHA256Length, '\0');
   hash.replace(0, hashed_ip_prefix.size(), hashed_ip_prefix);
   hash[base::kSHA1Length] = static_cast<char>(prefix_size);
   return hash;
@@ skipping 19 matching lines @@
 // one url for prefix.
 void InsertAddChunkHostPrefixUrl(SBChunk* chunk,
                                  int chunk_number,
                                  const std::string& host_name,
                                  const std::string& url) {
   InsertAddChunkHostPrefixValue(chunk, chunk_number,
                                 SBPrefixForString(host_name),
                                 SBPrefixForString(url));
 }
 
+// Same as InsertAddChunkHostFullHashes, but with pre-computed
+// prefix and fullhash values.
+void InsertAddChunkHostFullHashValue(SBChunk* chunk,
+                                     int chunk_number,
+                                     const SBPrefix& host_prefix,
+                                     const SBFullHash& url_fullhash) {
+  chunk->chunk_number = chunk_number;
+  chunk->is_add = true;
+  SBChunkHost host;
+  host.host = host_prefix;
+  host.entry = SBEntry::Create(SBEntry::ADD_FULL_HASH, 1);
+  host.entry->set_chunk_id(chunk->chunk_number);
+  host.entry->SetFullHashAt(0, url_fullhash);
+  chunk->hosts.push_back(host);
+}
+
 // Same as InsertAddChunkHostPrefixUrl, but with full hashes.
 void InsertAddChunkHostFullHashes(SBChunk* chunk,
                                   int chunk_number,
                                   const std::string& host_name,
                                   const std::string& url) {
-  chunk->chunk_number = chunk_number;
-  chunk->is_add = true;
-  SBChunkHost host;
-  host.host = SBPrefixForString(host_name);
-  host.entry = SBEntry::Create(SBEntry::ADD_FULL_HASH, 1);
-  host.entry->set_chunk_id(chunk->chunk_number);
-  host.entry->SetFullHashAt(0, SBFullHashForString(url));
-  chunk->hosts.push_back(host);
+  InsertAddChunkHostFullHashValue(chunk,
+                                  chunk_number,
+                                  SBPrefixForString(host_name),
+                                  SBFullHashForString(url));
 }
 
 void InsertAddChunkFullHash(SBChunk* chunk,
                             int chunk_number,
                             const std::string& ip_str,
                             size_t prefix_size) {
   const std::string full_hash_str = HashedIpPrefix(ip_str, prefix_size);
   EXPECT_EQ(sizeof(SBFullHash), full_hash_str.size());
   SBFullHash full_hash;
   std::memcpy(&(full_hash.full_hash), full_hash_str.data(), sizeof(SBFullHash));
@@ skipping 86 matching lines @@
   host.host = SBPrefixForString(host_name);
   host.entry = SBEntry::Create(SBEntry::SUB_PREFIX, 2);
   host.entry->set_chunk_id(chunk->chunk_number);
   host.entry->SetPrefixAt(0, SBPrefixForString(url1));
   host.entry->SetChunkIdAtPrefix(0, chunk_id_to_sub);
   host.entry->SetPrefixAt(1, SBPrefixForString(url2));
   host.entry->SetChunkIdAtPrefix(1, chunk_id_to_sub);
   chunk->hosts.push_back(host);
 }
 
-// Same as InsertSubChunkHost2PrefixUrls, but with full hashes.
+// Same as InsertSubChunkHostFullHash but with pre-computed hashes.
+void InsertSubChunkHostFullHashValue(SBChunk* chunk,
+                                     int chunk_number,
+                                     int chunk_id_to_sub,
+                                     const SBPrefix& host_prefix,
+                                     const SBFullHash& url_fullhash) {
+  chunk->chunk_number = chunk_number;
+  chunk->is_add = false;
+  SBChunkHost host;
+  host.host = host_prefix;
+  host.entry = SBEntry::Create(SBEntry::SUB_FULL_HASH, 1);
+  host.entry->set_chunk_id(chunk->chunk_number);
+  host.entry->SetFullHashAt(0, url_fullhash);
+  host.entry->SetChunkIdAtPrefix(0, chunk_id_to_sub);
+  chunk->hosts.push_back(host);
+}
+
+// Same as InsertSubChunkHostPrefixUrl, but with full hash.
 void InsertSubChunkHostFullHash(SBChunk* chunk,
                                 int chunk_number,
                                 int chunk_id_to_sub,
                                 const std::string& host_name,
                                 const std::string& url) {
-  chunk->chunk_number = chunk_number;
-  chunk->is_add = false;
-  SBChunkHost host;
-  host.host = SBPrefixForString(host_name);
-  host.entry = SBEntry::Create(SBEntry::SUB_FULL_HASH, 2);
-  host.entry->set_chunk_id(chunk->chunk_number);
-  host.entry->SetFullHashAt(0, SBFullHashForString(url));
-  host.entry->SetChunkIdAtPrefix(0, chunk_id_to_sub);
-  chunk->hosts.push_back(host);
+  InsertSubChunkHostFullHashValue(chunk,
+                                  chunk_number,
+                                  chunk_id_to_sub,
+                                  SBPrefixForString(host_name),
+                                  SBFullHashForString(url));
 }
 
 // Prevent DCHECK from killing tests.
 // TODO(shess): Pawel disputes the use of this, so the test which uses
 // it is DISABLED.  http://crbug.com/56448
 class ScopedLogMessageIgnorer {
  public:
   ScopedLogMessageIgnorer() {
     logging::SetLogMessageHandler(&LogMessageIgnorer);
   }
@@ skipping 38 matching lines @@
   }
 
   virtual void TearDown() {
     database_.reset();
 
     PlatformTest::TearDown();
   }
 
   void GetListsInfo(std::vector<SBListChunkRanges>* lists) {
     lists->clear();
-    EXPECT_TRUE(database_->UpdateStarted(lists));
+    ASSERT_TRUE(database_->UpdateStarted(lists));
     database_->UpdateFinished(true);
   }
 
   // Helper function to do an AddDel or SubDel command.
   void DelChunk(const std::string& list,
                 int chunk_id,
                 bool is_sub_del) {
     std::vector<SBChunkDelete> deletes;
     SBChunkDelete chunk_delete;
     chunk_delete.list_name = list;
     chunk_delete.is_sub_del = is_sub_del;
     chunk_delete.chunk_del.push_back(ChunkRange(chunk_id));
     deletes.push_back(chunk_delete);
     database_->DeleteChunks(deletes);
   }
 
   void AddDelChunk(const std::string& list, int chunk_id) {
     DelChunk(list, chunk_id, false);
   }
 
   void SubDelChunk(const std::string& list, int chunk_id) {
     DelChunk(list, chunk_id, true);
   }
 
+  bool ContainsBrowseUrlHashes(std::vector<SBFullHash>* full_hashes,
+                               std::vector<SBPrefix>* prefix_hits,
+                               std::vector<SBFullHashResult>* cache_hits) {
+    std::sort(full_hashes->begin(), full_hashes->end(), SBFullHashLess);
+    return database_->ContainsBrowseUrlHashes(
+        *full_hashes, prefix_hits, cache_hits);
+  }
+
   // Utility function for setting up the database for the caching test.
   void PopulateDatabaseForCacheTest();
 
   scoped_ptr<SafeBrowsingDatabaseNew> database_;
   base::FilePath database_filename_;
   base::ScopedTempDir temp_dir_;
 };
 
 // Tests retrieving list name information.
 TEST_F(SafeBrowsingDatabaseTest, ListNameForBrowse) {
   SBChunkList chunks;
   SBChunk chunk;
 
   InsertAddChunkHostPrefixUrl(&chunk, 1, "www.evil.com/",
                               "www.evil.com/malware.html");
   chunks.clear();
   chunks.push_back(chunk);
   std::vector<SBListChunkRanges> lists;
-  EXPECT_TRUE(database_->UpdateStarted(&lists));
+  ASSERT_TRUE(database_->UpdateStarted(&lists));
   database_->InsertChunks(safe_browsing_util::kMalwareList, chunks);
 
   chunk.hosts.clear();
   InsertAddChunkHostPrefixUrl(&chunk, 2, "www.foo.com/",
                               "www.foo.com/malware.html");
   chunks.clear();
   chunks.push_back(chunk);
   database_->InsertChunks(safe_browsing_util::kMalwareList, chunks);
 
   chunk.hosts.clear();
   InsertAddChunkHostPrefixUrl(&chunk, 3, "www.whatever.com/",
                               "www.whatever.com/malware.html");
   chunks.clear();
   chunks.push_back(chunk);
   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].adds, "1-3");
   EXPECT_TRUE(lists[0].subs.empty());
 
   // Insert a malware sub chunk.
   chunk.hosts.clear();
   InsertSubChunkHostPrefixUrl(&chunk, 7, 19, "www.subbed.com/",
                               "www.subbed.com/noteveil1.html");
   chunks.clear();
   chunks.push_back(chunk);
 
-  EXPECT_TRUE(database_->UpdateStarted(&lists));
+  ASSERT_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].adds, "1-3");
   EXPECT_EQ(lists[0].subs, "7");
   if (lists.size() == 2) {
     // Old style database won't have the second entry since it creates the lists
     // when it receives an update containing that list. The filter-based
     // database has these values hard coded.
     EXPECT_TRUE(lists[1].name == safe_browsing_util::kPhishingList);
     EXPECT_TRUE(lists[1].adds.empty());
     EXPECT_TRUE(lists[1].subs.empty());
   }
 
   // Add a phishing add chunk.
   chunk.hosts.clear();
   InsertAddChunkHostPrefixUrl(&chunk, 47, "www.evil.com/",
                               "www.evil.com/phishing.html");
   chunks.clear();
   chunks.push_back(chunk);
-  EXPECT_TRUE(database_->UpdateStarted(&lists));
+  ASSERT_TRUE(database_->UpdateStarted(&lists));
   database_->InsertChunks(safe_browsing_util::kPhishingList, chunks);
 
   // Insert some phishing sub chunks.
   chunk.hosts.clear();
   InsertSubChunkHostPrefixUrl(&chunk, 200, 1999, "www.phishy.com/",
                               "www.phishy.com/notevil1.html");
   chunks.clear();
   chunks.push_back(chunk);
   database_->InsertChunks(safe_browsing_util::kPhishingList, chunks);
 
@@ skipping 34 matching lines @@
   database_->Init(database_filename_);
 
   SBChunkList chunks;
   SBChunk chunk;
 
   // Insert malware, phish, binurl and bindownload add chunks.
   InsertAddChunkHostPrefixUrl(&chunk, 1, "www.evil.com/",
                               "www.evil.com/malware.html");
   chunks.push_back(chunk);
   std::vector<SBListChunkRanges> lists;
-  EXPECT_TRUE(database_->UpdateStarted(&lists));
+  ASSERT_TRUE(database_->UpdateStarted(&lists));
   database_->InsertChunks(safe_browsing_util::kMalwareList, chunks);
 
   chunk.hosts.clear();
   InsertAddChunkHostPrefixUrl(&chunk, 2, "www.foo.com/",
                               "www.foo.com/malware.html");
   chunks.clear();
   chunks.push_back(chunk);
   database_->InsertChunks(safe_browsing_util::kPhishingList, chunks);
 
   chunk.hosts.clear();
@@ skipping 67 matching lines @@
 TEST_F(SafeBrowsingDatabaseTest, BrowseDatabase) {
   SBChunkList chunks;
   SBChunk chunk;
 
   // Add a simple chunk with one hostkey.
   InsertAddChunkHost2PrefixUrls(&chunk, 1, "www.evil.com/",
                                 "www.evil.com/phishing.html",
                                 "www.evil.com/malware.html");
   chunks.push_back(chunk);
   std::vector<SBListChunkRanges> lists;
-  EXPECT_TRUE(database_->UpdateStarted(&lists));
+  ASSERT_TRUE(database_->UpdateStarted(&lists));
   database_->InsertChunks(safe_browsing_util::kMalwareList, chunks);
 
   chunk.hosts.clear();
   InsertAddChunkHost2PrefixUrls(&chunk, 2, "www.evil.com/",
                                 "www.evil.com/notevil1.html",
                                 "www.evil.com/notevil2.html");
   InsertAddChunkHost2PrefixUrls(&chunk, 2, "www.good.com/",
                                 "www.good.com/good1.html",
                                 "www.good.com/good2.html");
   chunks.clear();
   chunks.push_back(chunk);
   database_->InsertChunks(safe_browsing_util::kMalwareList, chunks);
 
   // and a chunk with an IP-based host
   chunk.hosts.clear();
   InsertAddChunkHostPrefixUrl(&chunk, 3, "192.168.0.1/",
                               "192.168.0.1/malware.html");
   chunks.clear();
   chunks.push_back(chunk);
   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");
   EXPECT_TRUE(lists[0].subs.empty());
 
-  const Time now = Time::Now();
-  std::vector<SBFullHashResult> full_hashes;
+  std::vector<SBFullHashResult> cache_hits;
   std::vector<SBPrefix> prefix_hits;
-  std::string matching_list;
   EXPECT_TRUE(database_->ContainsBrowseUrl(
-      GURL("http://www.evil.com/phishing.html"),
-      &matching_list, &prefix_hits,
-      &full_hashes, now));
+      GURL("http://www.evil.com/phishing.html"), &prefix_hits, &cache_hits));
   EXPECT_EQ(prefix_hits[0], SBPrefixForString("www.evil.com/phishing.html"));
   EXPECT_EQ(prefix_hits.size(), 1U);
+  EXPECT_TRUE(cache_hits.empty());
 
   EXPECT_TRUE(database_->ContainsBrowseUrl(
-      GURL("http://www.evil.com/malware.html"),
-      &matching_list, &prefix_hits,
-      &full_hashes, now));
+      GURL("http://www.evil.com/malware.html"), &prefix_hits, &cache_hits));
 
   EXPECT_TRUE(database_->ContainsBrowseUrl(
-      GURL("http://www.evil.com/notevil1.html"),
-      &matching_list, &prefix_hits,
-      &full_hashes, now));
+      GURL("http://www.evil.com/notevil1.html"), &prefix_hits, &cache_hits));
 
   EXPECT_TRUE(database_->ContainsBrowseUrl(
-      GURL("http://www.evil.com/notevil2.html"),
-      &matching_list, &prefix_hits,
-      &full_hashes, now));
+      GURL("http://www.evil.com/notevil2.html"), &prefix_hits, &cache_hits));
 
   EXPECT_TRUE(database_->ContainsBrowseUrl(
-      GURL("http://www.good.com/good1.html"),
-      &matching_list, &prefix_hits,
-      &full_hashes, now));
+      GURL("http://www.good.com/good1.html"), &prefix_hits, &cache_hits));
 
   EXPECT_TRUE(database_->ContainsBrowseUrl(
-      GURL("http://www.good.com/good2.html"),
-      &matching_list, &prefix_hits,
-      &full_hashes, now));
+      GURL("http://www.good.com/good2.html"), &prefix_hits, &cache_hits));
 
   EXPECT_TRUE(database_->ContainsBrowseUrl(
-      GURL("http://192.168.0.1/malware.html"),
-      &matching_list, &prefix_hits,
-      &full_hashes, now));
+      GURL("http://192.168.0.1/malware.html"), &prefix_hits, &cache_hits));
 
   EXPECT_FALSE(database_->ContainsBrowseUrl(
-      GURL("http://www.evil.com/"),
-      &matching_list, &prefix_hits,
-      &full_hashes, now));
+      GURL("http://www.evil.com/"), &prefix_hits, &cache_hits));
   EXPECT_TRUE(prefix_hits.empty());
+  EXPECT_TRUE(cache_hits.empty());
 
   EXPECT_FALSE(database_->ContainsBrowseUrl(
-      GURL("http://www.evil.com/robots.txt"),
-      &matching_list, &prefix_hits,
-      &full_hashes, now));
+      GURL("http://www.evil.com/robots.txt"), &prefix_hits, &cache_hits));
 
   // 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();
   chunks.push_back(chunk);
-  EXPECT_TRUE(database_->UpdateStarted(&lists));
+  ASSERT_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].adds, "1-3");
   EXPECT_TRUE(lists[0].subs.empty());
 
   // Test removing a single prefix from the add chunk.
   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));
+  ASSERT_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"),
-      &matching_list, &prefix_hits,
-      &full_hashes, now));
+      GURL("http://www.evil.com/phishing.html"), &prefix_hits, &cache_hits));
   EXPECT_EQ(prefix_hits[0], SBPrefixForString("www.evil.com/phishing.html"));
   EXPECT_EQ(prefix_hits.size(), 1U);
+  EXPECT_TRUE(cache_hits.empty());
 
   EXPECT_FALSE(database_->ContainsBrowseUrl(
-      GURL("http://www.evil.com/notevil1.html"),
-      &matching_list, &prefix_hits,
-      &full_hashes, now));
+      GURL("http://www.evil.com/notevil1.html"), &prefix_hits, &cache_hits));
   EXPECT_TRUE(prefix_hits.empty());
+  EXPECT_TRUE(cache_hits.empty());
 
   EXPECT_TRUE(database_->ContainsBrowseUrl(
-      GURL("http://www.evil.com/notevil2.html"),
-      &matching_list, &prefix_hits,
-      &full_hashes, now));
+      GURL("http://www.evil.com/notevil2.html"), &prefix_hits, &cache_hits));
 
   EXPECT_TRUE(database_->ContainsBrowseUrl(
-      GURL("http://www.good.com/good1.html"),
-      &matching_list, &prefix_hits,
-      &full_hashes, now));
+      GURL("http://www.good.com/good1.html"), &prefix_hits, &cache_hits));
 
   EXPECT_TRUE(database_->ContainsBrowseUrl(
-      GURL("http://www.good.com/good2.html"),
-      &matching_list, &prefix_hits,
-      &full_hashes, now));
+      GURL("http://www.good.com/good2.html"), &prefix_hits, &cache_hits));
 
   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));
+  ASSERT_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));
+  ASSERT_TRUE(database_->UpdateStarted(&lists));
   AddDelChunk(safe_browsing_util::kMalwareList, 2);
   database_->UpdateFinished(true);
 
   EXPECT_FALSE(database_->ContainsBrowseUrl(
-      GURL("http://www.evil.com/notevil2.html"),
-      &matching_list, &prefix_hits,
-      &full_hashes, now));
+      GURL("http://www.evil.com/notevil2.html"), &prefix_hits, &cache_hits));
 
   EXPECT_FALSE(database_->ContainsBrowseUrl(
-      GURL("http://www.good.com/good1.html"),
-      &matching_list, &prefix_hits,
-      &full_hashes, now));
+      GURL("http://www.good.com/good1.html"), &prefix_hits, &cache_hits));
 
   EXPECT_FALSE(database_->ContainsBrowseUrl(
-      GURL("http://www.good.com/good2.html"),
-      &matching_list, &prefix_hits,
-      &full_hashes, now));
+      GURL("http://www.good.com/good2.html"), &prefix_hits, &cache_hits));
 
   GetListsInfo(&lists);
   EXPECT_TRUE(lists[0].name == safe_browsing_util::kMalwareList);
   EXPECT_EQ(lists[0].adds, "1,3");
   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();
   InsertAddChunkHostPrefixUrl(&chunk, 44, "www.redherring.com/",
                               "www.redherring.com/index.html");
   chunks.clear();
   chunks.push_back(chunk);
-  EXPECT_TRUE(database_->UpdateStarted(&lists));
+  ASSERT_TRUE(database_->UpdateStarted(&lists));
   database_->InsertChunks(safe_browsing_util::kMalwareList, chunks);
 
   // Now remove the dummy entry.  If there are any problems with the
   // transactions, asserts will fire.
   AddDelChunk(safe_browsing_util::kMalwareList, 44);
 
   // Test the subdel command.
   SubDelChunk(safe_browsing_util::kMalwareList, 4);
   database_->UpdateFinished(true);
 
   GetListsInfo(&lists);
   EXPECT_TRUE(lists[0].name == safe_browsing_util::kMalwareList);
   EXPECT_EQ(lists[0].adds, "1,3");
   EXPECT_EQ(lists[0].subs, "");
 
   // Test a sub command coming in before the add.
   chunk.hosts.clear();
   InsertSubChunkHost2PrefixUrls(&chunk, 5, 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));
+  ASSERT_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"),
-      &matching_list, &prefix_hits, &full_hashes, now));
+      &prefix_hits,
+      &cache_hits));
 
   // 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));
+  ASSERT_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"),
-      &matching_list, &prefix_hits, &full_hashes, now));
+      &prefix_hits,
+      &cache_hits));
 
   EXPECT_FALSE(database_->ContainsBrowseUrl(
       GURL("http://www.notevilanymore.com/good.html"),
-      &matching_list, &prefix_hits, &full_hashes, now));
+      &prefix_hits,
+      &cache_hits));
 }
 
 
 // Test adding zero length chunks to the database.
 TEST_F(SafeBrowsingDatabaseTest, ZeroSizeChunk) {
   SBChunkList chunks;
   SBChunk chunk;
 
   // Populate with a couple of normal chunks.
   InsertAddChunkHost2PrefixUrls(&chunk, 1, "www.test.com/",
                                 "www.test.com/test1.html",
                                 "www.test.com/test2.html");
   chunks.clear();
   chunks.push_back(chunk);
 
   chunk.hosts.clear();
   InsertAddChunkHost2PrefixUrls(&chunk, 10, "www.random.com/",
                                 "www.random.com/random1.html",
                                 "www.random.com/random2.html");
   chunks.push_back(chunk);
 
   std::vector<SBListChunkRanges> lists;
-  EXPECT_TRUE(database_->UpdateStarted(&lists));
+  ASSERT_TRUE(database_->UpdateStarted(&lists));
   database_->InsertChunks(safe_browsing_util::kMalwareList, chunks);
   database_->UpdateFinished(true);
 
   // Add an empty ADD and SUB chunk.
   GetListsInfo(&lists);
   EXPECT_EQ(lists[0].adds, "1,10");
 
   SBChunk empty_chunk;
   empty_chunk.chunk_number = 19;
   empty_chunk.is_add = true;
   chunks.clear();
   chunks.push_back(empty_chunk);
-  EXPECT_TRUE(database_->UpdateStarted(&lists));
+  ASSERT_TRUE(database_->UpdateStarted(&lists));
   database_->InsertChunks(safe_browsing_util::kMalwareList, chunks);
   chunks.clear();
   empty_chunk.chunk_number = 7;
   empty_chunk.is_add = false;
   chunks.push_back(empty_chunk);
   database_->InsertChunks(safe_browsing_util::kMalwareList, chunks);
   database_->UpdateFinished(true);
 
   GetListsInfo(&lists);
   EXPECT_EQ(lists[0].adds, "1,10,19");
@@ skipping 10 matching lines @@
   empty_chunk.chunk_number = 21;
   empty_chunk.is_add = true;
   empty_chunk.hosts.clear();
   chunks.push_back(empty_chunk);
 
   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));
+  ASSERT_TRUE(database_->UpdateStarted(&lists));
   database_->InsertChunks(safe_browsing_util::kMalwareList, chunks);
   database_->UpdateFinished(true);
 
-  const Time now = Time::Now();
-  std::vector<SBFullHashResult> full_hashes;
+  std::vector<SBFullHashResult> cache_hits;
   std::vector<SBPrefix> prefix_hits;
-  std::string matching_list;
   EXPECT_TRUE(database_->ContainsBrowseUrl(
-      GURL("http://www.notempty.com/full1.html"),
-      &matching_list, &prefix_hits,
-      &full_hashes, now));
+      GURL("http://www.notempty.com/full1.html"), &prefix_hits, &cache_hits));
   EXPECT_TRUE(database_->ContainsBrowseUrl(
-      GURL("http://www.notempty.com/full2.html"),
-      &matching_list, &prefix_hits,
-      &full_hashes, now));
+      GURL("http://www.notempty.com/full2.html"), &prefix_hits, &cache_hits));
 
   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));
+  ASSERT_TRUE(database_->UpdateStarted(&lists));
   AddDelChunk(safe_browsing_util::kMalwareList, 21);
   database_->UpdateFinished(true);
 
   GetListsInfo(&lists);
   EXPECT_EQ(lists[0].adds, "1,10,19-20,22");
   EXPECT_EQ(lists[0].subs, "7");
 
-  EXPECT_TRUE(database_->UpdateStarted(&lists));
+  ASSERT_TRUE(database_->UpdateStarted(&lists));
   SubDelChunk(safe_browsing_util::kMalwareList, 7);
   database_->UpdateFinished(true);
 
   GetListsInfo(&lists);
   EXPECT_EQ(lists[0].adds, "1,10,19-20,22");
   EXPECT_EQ(lists[0].subs, "");
 }
 
 // Utility function for setting up the database for the caching test.
 void SafeBrowsingDatabaseTest::PopulateDatabaseForCacheTest() {
   SBChunkList chunks;
   SBChunk chunk;
   // Add a simple chunk with one hostkey and cache it.
   InsertAddChunkHost2PrefixUrls(&chunk, 1, "www.evil.com/",
                                 "www.evil.com/phishing.html",
                                 "www.evil.com/malware.html");
   chunks.push_back(chunk);
 
   std::vector<SBListChunkRanges> lists;
-  EXPECT_TRUE(database_->UpdateStarted(&lists));
+  ASSERT_TRUE(database_->UpdateStarted(&lists));
   database_->InsertChunks(safe_browsing_util::kMalwareList, chunks);
   database_->UpdateFinished(true);
 
+  // Cache should be cleared after updating.
+  EXPECT_TRUE(database_->browse_gethash_cache_.empty());
+
   // Add the GetHash results to the cache.
   SBFullHashResult full_hash;
   full_hash.hash = SBFullHashForString("www.evil.com/phishing.html");
   full_hash.list_name = safe_browsing_util::kMalwareList;
-  full_hash.add_chunk_id = 1;
 
   std::vector<SBFullHashResult> results;
+  std::vector<SBPrefix> prefixes;
   results.push_back(full_hash);
+  prefixes.push_back(full_hash.hash.prefix);
+  database_->CacheHashResults(
+      prefixes, results, base::TimeDelta::FromMinutes(45));
 
   full_hash.hash = SBFullHashForString("www.evil.com/malware.html");
+  results.clear();
+  prefixes.clear();
   results.push_back(full_hash);
-
-  std::vector<SBPrefix> prefixes;
-  database_->CacheHashResults(prefixes, results);
+  prefixes.push_back(full_hash.hash.prefix);
+  database_->CacheHashResults(
+      prefixes, results, base::TimeDelta::FromMinutes(45));
 }
 
 TEST_F(SafeBrowsingDatabaseTest, HashCaching) {
   PopulateDatabaseForCacheTest();
 
   // We should have both full hashes in the cache.
-  EXPECT_EQ(database_->pending_browse_hashes_.size(), 2U);
+  EXPECT_EQ(database_->browse_gethash_cache_.size(), 2U);
 
   // Test the cache lookup for the first prefix.
   std::string listname;
   std::vector<SBPrefix> prefixes;
-  std::vector<SBFullHashResult> full_hashes;
+  std::vector<SBFullHashResult> cache_hits;
   database_->ContainsBrowseUrl(
-      GURL("http://www.evil.com/phishing.html"),
-      &listname, &prefixes, &full_hashes, Time::Now());
-  EXPECT_EQ(full_hashes.size(), 1U);
-  EXPECT_TRUE(
-      SBFullHashEqual(full_hashes[0].hash,
-                      SBFullHashForString("www.evil.com/phishing.html")));
+      GURL("http://www.evil.com/phishing.html"), &prefixes, &cache_hits);
+  EXPECT_TRUE(prefixes.empty());
+  ASSERT_EQ(cache_hits.size(), 1U);
+  EXPECT_TRUE(SBFullHashEqual(
+      cache_hits[0].hash, SBFullHashForString("www.evil.com/phishing.html")));
 
   prefixes.clear();
-  full_hashes.clear();
+  cache_hits.clear();
 
   // Test the cache lookup for the second prefix.
   database_->ContainsBrowseUrl(
-      GURL("http://www.evil.com/malware.html"),
-      &listname, &prefixes, &full_hashes, Time::Now());
-  EXPECT_EQ(full_hashes.size(), 1U);
-  EXPECT_TRUE(
-      SBFullHashEqual(full_hashes[0].hash,
-                      SBFullHashForString("www.evil.com/malware.html")));
+      GURL("http://www.evil.com/malware.html"), &prefixes, &cache_hits);
+  EXPECT_TRUE(prefixes.empty());
+  ASSERT_EQ(cache_hits.size(), 1U);
+  EXPECT_TRUE(SBFullHashEqual(
+      cache_hits[0].hash, SBFullHashForString("www.evil.com/malware.html")));
 
   prefixes.clear();
-  full_hashes.clear();
+  cache_hits.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));
+  ASSERT_TRUE(database_->UpdateStarted(&lists));
   database_->InsertChunks(safe_browsing_util::kMalwareList, chunks);
   database_->UpdateFinished(true);
 
-  // This prefix should still be there.
+  // This prefix should still be there, but cached fullhash should be gone.
   database_->ContainsBrowseUrl(
-      GURL("http://www.evil.com/malware.html"),
-      &listname, &prefixes, &full_hashes, Time::Now());
-  EXPECT_EQ(full_hashes.size(), 1U);
-  EXPECT_TRUE(
-      SBFullHashEqual(full_hashes[0].hash,
-                      SBFullHashForString("www.evil.com/malware.html")));
+      GURL("http://www.evil.com/malware.html"), &prefixes, &cache_hits);
+  EXPECT_TRUE(cache_hits.empty());
+  ASSERT_EQ(prefixes.size(), 1U);
+  EXPECT_EQ(prefixes[0], SBPrefixForString("www.evil.com/malware.html"));
   prefixes.clear();
-  full_hashes.clear();
+  cache_hits.clear();
 
   // This prefix should be gone.
   database_->ContainsBrowseUrl(
-      GURL("http://www.evil.com/phishing.html"),
-      &listname, &prefixes, &full_hashes, Time::Now());
-  EXPECT_TRUE(full_hashes.empty());
+      GURL("http://www.evil.com/phishing.html"), &prefixes, &cache_hits);
+  EXPECT_TRUE(prefixes.empty());
+  EXPECT_TRUE(cache_hits.empty());
 
   prefixes.clear();
-  full_hashes.clear();
+  cache_hits.clear();
 
-  // Test that an AddDel for the original chunk removes the last cached entry.
-  EXPECT_TRUE(database_->UpdateStarted(&lists));
+  // Test that an AddDel for the original chunk removes the last entry.
+  ASSERT_TRUE(database_->UpdateStarted(&lists));
   AddDelChunk(safe_browsing_util::kMalwareList, 1);
   database_->UpdateFinished(true);
   database_->ContainsBrowseUrl(
-      GURL("http://www.evil.com/malware.html"),
-      &listname, &prefixes, &full_hashes, Time::Now());
-  EXPECT_TRUE(full_hashes.empty());
+      GURL("http://www.evil.com/malware.html"), &prefixes, &cache_hits);
+  EXPECT_TRUE(cache_hits.empty());
   EXPECT_TRUE(database_->full_browse_hashes_.empty());
-  EXPECT_TRUE(database_->pending_browse_hashes_.empty());
+  EXPECT_TRUE(database_->browse_gethash_cache_.empty());
 
   prefixes.clear();
-  full_hashes.clear();
+  cache_hits.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<SBAddFullHash>* hash_cache = &database_->pending_browse_hashes_;
+  std::map<SBPrefix, SBCachedFullHashResult>* hash_cache =
+      &database_->browse_gethash_cache_;
   EXPECT_EQ(hash_cache->size(), 2U);
 
   // Now adjust one of the entries times to be in the past.
-  base::Time expired = base::Time::Now() - base::TimeDelta::FromMinutes(60);
   const SBPrefix key = SBPrefixForString("www.evil.com/malware.html");
-  std::vector<SBAddFullHash>::iterator iter;
-  for (iter = hash_cache->begin(); iter != hash_cache->end(); ++iter) {
-    if (iter->full_hash.prefix == key) {
-      iter->received = static_cast<int32>(expired.ToTimeT());
-      break;
-    }
-  }
-  EXPECT_TRUE(iter != hash_cache->end());
+  std::map<SBPrefix, SBCachedFullHashResult>::iterator iter =
+      hash_cache->find(key);
+  ASSERT_TRUE(iter != hash_cache->end());
+  iter->second.expire_after =
+      base::Time::Now() - base::TimeDelta::FromMinutes(1);
 
   database_->ContainsBrowseUrl(
-      GURL("http://www.evil.com/malware.html"),
-      &listname, &prefixes, &full_hashes, expired);
-  EXPECT_TRUE(full_hashes.empty());
+      GURL("http://www.evil.com/malware.html"), &prefixes, &cache_hits);
+  EXPECT_EQ(prefixes.size(), 1U);
+  EXPECT_TRUE(cache_hits.empty());
+  // Expired entry should have been removed from cache.
+  EXPECT_EQ(hash_cache->size(), 1U);
 
   // This entry should still exist.
   database_->ContainsBrowseUrl(
-      GURL("http://www.evil.com/phishing.html"),
-      &listname, &prefixes, &full_hashes, expired);
-  EXPECT_EQ(full_hashes.size(), 1U);
-
+      GURL("http://www.evil.com/phishing.html"), &prefixes, &cache_hits);
+  EXPECT_TRUE(prefixes.empty());
+  EXPECT_EQ(cache_hits.size(), 1U);
 
   // Testing prefix miss caching. First, we clear out the existing database,
   // Since PopulateDatabaseForCacheTest() doesn't handle adding duplicate
   // chunks.
-  EXPECT_TRUE(database_->UpdateStarted(&lists));
+  ASSERT_TRUE(database_->UpdateStarted(&lists));
   AddDelChunk(safe_browsing_util::kMalwareList, 1);
   database_->UpdateFinished(true);
 
+  // Cache should be cleared after updating.
+  EXPECT_TRUE(hash_cache->empty());
+
   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, base::TimeDelta::FromMinutes(45));
 
   // Prefixes with no full results are misses.
-  EXPECT_EQ(database_->prefix_miss_cache_.size(), 2U);
+  EXPECT_EQ(hash_cache->size(), prefix_misses.size());
+  ASSERT_TRUE(
+      hash_cache->count(SBPrefixForString("http://www.bad.com/malware.html")));
+  EXPECT_TRUE(
+      hash_cache->find(SBPrefixForString("http://www.bad.com/malware.html"))
+          ->second.full_hashes.empty());
+  ASSERT_TRUE(
+      hash_cache->count(SBPrefixForString("http://www.bad.com/phishing.html")));
+  EXPECT_TRUE(
+      hash_cache->find(SBPrefixForString("http://www.bad.com/phishing.html"))
+          ->second.full_hashes.empty());
 
   // 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();
-  full_hashes.clear();
+  cache_hits.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, base::TimeDelta::FromMinutes(45));
   EXPECT_FALSE(database_->ContainsBrowseUrl(
-      GURL("http://www.evil.com/phishing.html"),
-      &listname, &prefixes,
-      &full_hashes, Time::Now()));
+      GURL("http://www.evil.com/phishing.html"), &prefixes, &cache_hits));
+  EXPECT_TRUE(prefixes.empty());
+  EXPECT_TRUE(cache_hits.empty());
 
   prefixes.clear();
-  full_hashes.clear();
+  cache_hits.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));
+  ASSERT_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"),
-      &listname, &prefixes, &full_hashes,
-      Time::Now()));
-  EXPECT_EQ(full_hashes.size(), 1U);
-  EXPECT_TRUE(
-      SBFullHashEqual(full_hashes[0].hash,
-                      SBFullHashForString("www.fullevil.com/bad1.html")));
+      GURL("http://www.fullevil.com/bad1.html"), &prefixes, &cache_hits));
+  ASSERT_EQ(prefixes.size(), 1U);
+  EXPECT_EQ(prefixes[0], SBPrefixForString("www.fullevil.com/bad1.html"));
+  EXPECT_TRUE(cache_hits.empty());
   prefixes.clear();
-  full_hashes.clear();
+  cache_hits.clear();
 
   EXPECT_TRUE(database_->ContainsBrowseUrl(
-      GURL("http://www.fullevil.com/bad2.html"),
-      &listname, &prefixes, &full_hashes,
-      Time::Now()));
-  EXPECT_EQ(full_hashes.size(), 1U);
-  EXPECT_TRUE(
-      SBFullHashEqual(full_hashes[0].hash,
-                      SBFullHashForString("www.fullevil.com/bad2.html")));
+      GURL("http://www.fullevil.com/bad2.html"), &prefixes, &cache_hits));
+  ASSERT_EQ(prefixes.size(), 1U);
+  EXPECT_EQ(prefixes[0], SBPrefixForString("www.fullevil.com/bad2.html"));
+  EXPECT_TRUE(cache_hits.empty());
   prefixes.clear();
-  full_hashes.clear();
+  cache_hits.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));
+  ASSERT_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"),
-      &listname, &prefixes, &full_hashes,
-      Time::Now()));
-  EXPECT_TRUE(full_hashes.empty());
+      GURL("http://www.fullevil.com/bad1.html"), &prefixes, &cache_hits));
+  EXPECT_TRUE(prefixes.empty());
+  EXPECT_TRUE(cache_hits.empty());
 
   // There should be one remaining full add.
   EXPECT_TRUE(database_->ContainsBrowseUrl(
-      GURL("http://www.fullevil.com/bad2.html"),
-      &listname, &prefixes, &full_hashes,
-      Time::Now()));
-  EXPECT_EQ(full_hashes.size(), 1U);
-  EXPECT_TRUE(
-      SBFullHashEqual(full_hashes[0].hash,
-                      SBFullHashForString("www.fullevil.com/bad2.html")));
+      GURL("http://www.fullevil.com/bad2.html"), &prefixes, &cache_hits));
+  ASSERT_EQ(prefixes.size(), 1U);
+  EXPECT_EQ(prefixes[0], SBPrefixForString("www.fullevil.com/bad2.html"));
+  EXPECT_TRUE(cache_hits.empty());
   prefixes.clear();
-  full_hashes.clear();
+  cache_hits.clear();
 
   // Now test an AddDel for the remaining full add.
-  EXPECT_TRUE(database_->UpdateStarted(&lists));
+  ASSERT_TRUE(database_->UpdateStarted(&lists));
   AddDelChunk(safe_browsing_util::kMalwareList, 20);
   database_->UpdateFinished(true);
 
   EXPECT_FALSE(database_->ContainsBrowseUrl(
-      GURL("http://www.fullevil.com/bad1.html"),
-      &listname, &prefixes, &full_hashes,
-      Time::Now()));
+      GURL("http://www.fullevil.com/bad1.html"), &prefixes, &cache_hits));
   EXPECT_FALSE(database_->ContainsBrowseUrl(
-      GURL("http://www.fullevil.com/bad2.html"),
-      &listname, &prefixes, &full_hashes,
-      Time::Now()));
+      GURL("http://www.fullevil.com/bad2.html"), &prefixes, &cache_hits));
 }
 
 // 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.
 // http://crbug.com/56448
 TEST_F(SafeBrowsingDatabaseTest, DISABLED_FileCorruptionHandling) {
   // Re-create the database in a captive message loop so that we can
   // influence task-posting.  Database specifically needs to the
   // file-backed.
   database_.reset();
   base::MessageLoop loop;
   SafeBrowsingStoreFile* store = new SafeBrowsingStoreFile();
   database_.reset(new SafeBrowsingDatabaseNew(store, NULL, NULL, NULL, NULL,
                                               NULL, NULL));
   database_->Init(database_filename_);
 
   // This will cause an empty database to be created.
   std::vector<SBListChunkRanges> lists;
-  EXPECT_TRUE(database_->UpdateStarted(&lists));
+  ASSERT_TRUE(database_->UpdateStarted(&lists));
   database_->UpdateFinished(true);
 
   // Create a sub chunk to insert.
   SBChunkList chunks;
   SBChunk chunk;
   SBChunkHost host;
   host.host = SBPrefixForString("www.subbed.com/");
   host.entry = SBEntry::Create(SBEntry::SUB_PREFIX, 1);
   host.entry->set_chunk_id(7);
   host.entry->SetChunkIdAtPrefix(0, 19);
@@ skipping 13 matching lines @@
   for (size_t i = 0; i < 8; ++i) {
     fputc('!', fp);
   }
   fclose(fp);
 
   {
     // The following code will cause DCHECKs, so suppress the crashes.
     ScopedLogMessageIgnorer ignorer;
 
     // Start an update.  The insert will fail due to corruption.
-    EXPECT_TRUE(database_->UpdateStarted(&lists));
+    ASSERT_TRUE(database_->UpdateStarted(&lists));
     database_->InsertChunks(safe_browsing_util::kMalwareList, chunks);
     database_->UpdateFinished(true);
 
     // Database file still exists until the corruption handler has run.
     EXPECT_TRUE(base::PathExists(database_filename_));
 
     // Flush through the corruption-handler task.
     VLOG(1) << "Expect failed check on: SafeBrowsing database reset";
     base::MessageLoop::current()->RunUntilIdle();
   }
 
   // Database file should not exist.
   EXPECT_FALSE(base::PathExists(database_filename_));
 
   // Run the update again successfully.
-  EXPECT_TRUE(database_->UpdateStarted(&lists));
+  ASSERT_TRUE(database_->UpdateStarted(&lists));
   database_->InsertChunks(safe_browsing_util::kMalwareList, chunks);
   database_->UpdateFinished(true);
   EXPECT_TRUE(base::PathExists(database_filename_));
 
   database_.reset();
 }
 
 // Checks database reading and writing.
 TEST_F(SafeBrowsingDatabaseTest, ContainsDownloadUrl) {
   database_.reset();
@@ skipping 14 matching lines @@
   const char kEvil1Url1[] = "www.evil1.com/download1/";
   const char kEvil1Url2[] = "www.evil1.com/download2.html";
 
   SBChunkList chunks;
   SBChunk chunk;
   // Add a simple chunk with one hostkey for download url list.
   InsertAddChunkHost2PrefixUrls(&chunk, 1, kEvil1Host,
                                 kEvil1Url1, kEvil1Url2);
   chunks.push_back(chunk);
   std::vector<SBListChunkRanges> lists;
-  EXPECT_TRUE(database_->UpdateStarted(&lists));
+  ASSERT_TRUE(database_->UpdateStarted(&lists));
   database_->InsertChunks(safe_browsing_util::kBinUrlList, chunks);
   database_->UpdateFinished(true);
 
   std::vector<SBPrefix> prefix_hits;
   std::vector<GURL> urls(1);
 
   urls[0] = GURL(std::string("http://") + kEvil1Url1);
   EXPECT_TRUE(database_->ContainsDownloadUrl(urls, &prefix_hits));
   ASSERT_EQ(prefix_hits.size(), 1U);
   EXPECT_EQ(prefix_hits[0], SBPrefixForString(kEvil1Url1));
@@ skipping 124 matching lines @@
 
   chunk.hosts.clear();
   InsertAddChunkHostFullHashes(&chunk, 3, kGoodString, kGoodString);
   download_chunks.push_back(chunk);
 
   chunk.hosts.clear();
   InsertAddChunkHostFullHashes(&chunk, 4, kGood3Host, kGood3Url1);
   download_chunks.push_back(chunk);
 
   std::vector<SBListChunkRanges> lists;
-  EXPECT_TRUE(database_->UpdateStarted(&lists));
+  ASSERT_TRUE(database_->UpdateStarted(&lists));
   database_->InsertChunks(safe_browsing_util::kCsdWhiteList,
                           csd_chunks);
   database_->InsertChunks(safe_browsing_util::kDownloadWhiteList,
                           download_chunks);
   database_->UpdateFinished(true);
 
   EXPECT_FALSE(database_->ContainsCsdWhitelistedUrl(
       GURL(std::string("http://") + kGood1Host)));
 
   EXPECT_TRUE(database_->ContainsCsdWhitelistedUrl(
@@ skipping 37 matching lines @@
   EXPECT_FALSE(database_->ContainsDownloadWhitelistedUrl(
       GURL(std::string("http://www.google.com/"))));
 
   // Test only add the malware IP killswitch
   csd_chunks.clear();
   chunk.hosts.clear();
   InsertAddChunkHostFullHashes(
       &chunk, 15, "sb-ssl.google.com/",
       "sb-ssl.google.com/safebrowsing/csd/killswitch_malware");
   csd_chunks.push_back(chunk);
-  EXPECT_TRUE(database_->UpdateStarted(&lists));
+  ASSERT_TRUE(database_->UpdateStarted(&lists));
   database_->InsertChunks(safe_browsing_util::kCsdWhiteList, csd_chunks);
   database_->UpdateFinished(true);
 
   EXPECT_TRUE(database_->IsMalwareIPMatchKillSwitchOn());
 
   // Test that the kill-switch works as intended.
   csd_chunks.clear();
   download_chunks.clear();
   lists.clear();
   chunk.hosts.clear();
   InsertAddChunkHostFullHashes(&chunk, 5, "sb-ssl.google.com/",
                                "sb-ssl.google.com/safebrowsing/csd/killswitch");
   csd_chunks.push_back(chunk);
   chunk.hosts.clear();
   InsertAddChunkHostFullHashes(&chunk, 5, "sb-ssl.google.com/",
                                "sb-ssl.google.com/safebrowsing/csd/killswitch");
   download_chunks.push_back(chunk);
 
-  EXPECT_TRUE(database_->UpdateStarted(&lists));
+  ASSERT_TRUE(database_->UpdateStarted(&lists));
   database_->InsertChunks(safe_browsing_util::kCsdWhiteList, csd_chunks);
   database_->InsertChunks(safe_browsing_util::kDownloadWhiteList,
                           download_chunks);
   database_->UpdateFinished(true);
 
   EXPECT_TRUE(database_->IsMalwareIPMatchKillSwitchOn());
   EXPECT_TRUE(database_->ContainsCsdWhitelistedUrl(
       GURL(std::string("https://") + kGood1Url2 + "/c.html")));
   EXPECT_TRUE(database_->ContainsCsdWhitelistedUrl(
       GURL(std::string("http://www.google.com/"))));
@@ skipping 25 matching lines @@
       &sub_chunk, 10, 15, "sb-ssl.google.com/",
       "sb-ssl.google.com/safebrowsing/csd/killswitch_malware");
   csd_chunks.push_back(sub_chunk);
 
   sub_chunk.hosts.clear();
   InsertSubChunkHostFullHash(&sub_chunk, 1, 5,
                              "sb-ssl.google.com/",
                              "sb-ssl.google.com/safebrowsing/csd/killswitch");
   download_chunks.push_back(sub_chunk);
 
-  EXPECT_TRUE(database_->UpdateStarted(&lists));
+  ASSERT_TRUE(database_->UpdateStarted(&lists));
   database_->InsertChunks(safe_browsing_util::kCsdWhiteList, csd_chunks);
   database_->InsertChunks(safe_browsing_util::kDownloadWhiteList,
                           download_chunks);
   database_->UpdateFinished(true);
 
   EXPECT_FALSE(database_->IsMalwareIPMatchKillSwitchOn());
   EXPECT_TRUE(database_->ContainsCsdWhitelistedUrl(
       GURL(std::string("https://") + kGood1Url2 + "/c.html")));
   EXPECT_TRUE(database_->ContainsCsdWhitelistedUrl(
       GURL(std::string("https://") + kGood2Url1 + "/c/bla")));
@@ skipping 24 matching lines @@
   // Add a malware add chunk with two entries of the same host.
   InsertAddChunkHostPrefixUrl(&chunk, 1, "www.evil.com/",
                               "www.evil.com/malware1.html");
   InsertAddChunkHostPrefixUrl(&chunk, 1, "www.evil.com/",
                               "www.evil.com/malware2.html");
   SBChunkList chunks;
   chunks.push_back(chunk);
 
   // Insert the testing chunks into database.
   std::vector<SBListChunkRanges> lists;
-  EXPECT_TRUE(database_->UpdateStarted(&lists));
+  ASSERT_TRUE(database_->UpdateStarted(&lists));
   database_->InsertChunks(safe_browsing_util::kMalwareList, chunks);
   database_->UpdateFinished(true);
 
   GetListsInfo(&lists);
   EXPECT_EQ(std::string(safe_browsing_util::kMalwareList), lists[0].name);
   EXPECT_EQ("1", lists[0].adds);
   EXPECT_TRUE(lists[0].subs.empty());
 
   // Add a phishing add chunk with two entries of the same host.
   chunk.hosts.clear();
   InsertAddChunkHostPrefixUrl(&chunk, 47, "www.evil.com/",
                               "www.evil.com/phishing1.html");
   InsertAddChunkHostPrefixUrl(&chunk, 47, "www.evil.com/",
                               "www.evil.com/phishing2.html");
   chunks.clear();
   chunks.push_back(chunk);
 
-  EXPECT_TRUE(database_->UpdateStarted(&lists));
+  ASSERT_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> full_hashes;
-  std::vector<SBPrefix> prefix_hits;
-  std::string matching_list;
+  std::vector<SBFullHashResult> cache_hits;
   std::string listname;
 
   EXPECT_TRUE(database_->ContainsBrowseUrl(
-      GURL("http://www.evil.com/malware1.html"),
-      &listname, &prefixes, &full_hashes, now));
+      GURL("http://www.evil.com/malware1.html"), &prefixes, &cache_hits));
   EXPECT_TRUE(database_->ContainsBrowseUrl(
-      GURL("http://www.evil.com/malware2.html"),
-      &listname, &prefixes, &full_hashes, now));
+      GURL("http://www.evil.com/malware2.html"), &prefixes, &cache_hits));
   EXPECT_TRUE(database_->ContainsBrowseUrl(
-      GURL("http://www.evil.com/phishing1.html"),
-      &listname, &prefixes, &full_hashes, now));
+      GURL("http://www.evil.com/phishing1.html"), &prefixes, &cache_hits));
   EXPECT_TRUE(database_->ContainsBrowseUrl(
-      GURL("http://www.evil.com/phishing2.html"),
-      &listname, &prefixes, &full_hashes, now));
+      GURL("http://www.evil.com/phishing2.html"), &prefixes, &cache_hits));
 
   // 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));
+  ASSERT_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));
+  ASSERT_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"),
-      &listname, &prefixes, &full_hashes, now));
+      GURL("http://www.evil.com/malware1.html"), &prefixes, &cache_hits));
   EXPECT_TRUE(database_->ContainsBrowseUrl(
-      GURL("http://www.evil.com/malware2.html"),
-      &listname, &prefixes, &full_hashes, now));
+      GURL("http://www.evil.com/malware2.html"), &prefixes, &cache_hits));
   EXPECT_TRUE(database_->ContainsBrowseUrl(
-      GURL("http://www.evil.com/phishing1.html"),
-      &listname, &prefixes, &full_hashes, now));
+      GURL("http://www.evil.com/phishing1.html"), &prefixes, &cache_hits));
   EXPECT_FALSE(database_->ContainsBrowseUrl(
-      GURL("http://www.evil.com/phishing2.html"),
-      &listname, &prefixes, &full_hashes, now));
+      GURL("http://www.evil.com/phishing2.html"), &prefixes, &cache_hits));
 }
 
 // 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));
+  ASSERT_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);
 
   // 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));
+  ASSERT_TRUE(database_->UpdateStarted(&lists));
   chunk.hosts.clear();
   InsertAddChunkHostPrefixUrl(&chunk, 2, "www.foo.com/",
                               "www.foo.com/malware.html");
   chunks.clear();
   chunks.push_back(chunk);
   database_->InsertChunks(safe_browsing_util::kMalwareList, chunks);
   database_->UpdateFinished(true);
   ASSERT_TRUE(base::GetFileInfo(filename, &after_info));
   EXPECT_LT(before_info.last_modified, after_info.last_modified);
 
   // Deleting a chunk updates the database file.
   ASSERT_TRUE(base::TouchFile(filename, old_last_modified, old_last_modified));
   ASSERT_TRUE(base::GetFileInfo(filename, &before_info));
-  EXPECT_TRUE(database_->UpdateStarted(&lists));
+  ASSERT_TRUE(database_->UpdateStarted(&lists));
   AddDelChunk(safe_browsing_util::kMalwareList, chunk.chunk_number);
   database_->UpdateFinished(true);
   ASSERT_TRUE(base::GetFileInfo(filename, &after_info));
   EXPECT_LT(before_info.last_modified, after_info.last_modified);
 
   // Simply calling |UpdateStarted()| then |UpdateFinished()| does not
   // update the database file.
   ASSERT_TRUE(base::TouchFile(filename, old_last_modified, old_last_modified));
   ASSERT_TRUE(base::GetFileInfo(filename, &before_info));
-  EXPECT_TRUE(database_->UpdateStarted(&lists));
+  ASSERT_TRUE(database_->UpdateStarted(&lists));
   database_->UpdateFinished(true);
   ASSERT_TRUE(base::GetFileInfo(filename, &after_info));
   EXPECT_EQ(before_info.last_modified, after_info.last_modified);
 }
 
 // Test that a filter file is written out during update and read back
 // in during setup.
 TEST_F(SafeBrowsingDatabaseTest, FilterFile) {
   // Create a database with trivial example data and write it out.
   {
     SBChunkList chunks;
     SBChunk chunk;
 
     // Prime the database.
     std::vector<SBListChunkRanges> lists;
-    EXPECT_TRUE(database_->UpdateStarted(&lists));
+    ASSERT_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);
   }
 
   // Find the malware url in the database, don't find a good url.
-  const Time now = Time::Now();
-  std::vector<SBFullHashResult> full_hashes;
+  std::vector<SBFullHashResult> cache_hits;
   std::vector<SBPrefix> prefix_hits;
-  std::string matching_list;
   EXPECT_TRUE(database_->ContainsBrowseUrl(
-      GURL("http://www.evil.com/malware.html"),
-      &matching_list, &prefix_hits, &full_hashes, now));
+      GURL("http://www.evil.com/malware.html"), &prefix_hits, &cache_hits));
   EXPECT_FALSE(database_->ContainsBrowseUrl(
-      GURL("http://www.good.com/goodware.html"),
-      &matching_list, &prefix_hits, &full_hashes, now));
+      GURL("http://www.good.com/goodware.html"), &prefix_hits, &cache_hits));
 
   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"),
-      &matching_list, &prefix_hits, &full_hashes, now));
+      GURL("http://www.evil.com/malware.html"), &prefix_hits, &cache_hits));
   EXPECT_FALSE(database_->ContainsBrowseUrl(
-      GURL("http://www.good.com/goodware.html"),
-      &matching_list, &prefix_hits, &full_hashes, now));
+      GURL("http://www.good.com/goodware.html"), &prefix_hits, &cache_hits));
 
   // 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"),
-      &matching_list, &prefix_hits, &full_hashes, now));
+      GURL("http://www.evil.com/malware.html"), &prefix_hits, &cache_hits));
   EXPECT_FALSE(database_->ContainsBrowseUrl(
-      GURL("http://www.good.com/goodware.html"),
-      &matching_list, &prefix_hits, &full_hashes, now));
+      GURL("http://www.good.com/goodware.html"), &prefix_hits, &cache_hits));
 }
 
+TEST_F(SafeBrowsingDatabaseTest, TestCachedFullMiss) {
+  std::vector<SBListChunkRanges> lists;
+  ASSERT_TRUE(database_->UpdateStarted(&lists));
+
+  SBChunkList chunks;
+  {
+    // Insert prefix 1001 into database.
+    SBChunk chunk;
+    InsertAddChunkHostPrefixValue(&chunk, 1, SBPrefix(100), SBPrefix(1001));
+    chunks.push_back(chunk);
+  }
+  {
+    // Insert prefix 1002 into database.
+    SBChunk chunk;
+    InsertAddChunkHostPrefixValue(&chunk, 2, SBPrefix(101), SBPrefix(1002));
+    chunks.push_back(chunk);
+  }
+
+  database_->InsertChunks(safe_browsing_util::kMalwareList, chunks);
+  database_->UpdateFinished(true);
+
+  {
+    // Cache a full miss result for 1001.
+    std::vector<SBPrefix> prefixes;
+    prefixes.push_back(SBPrefix(1001));
+    std::vector<SBFullHashResult> cache_results;
+    database_->CacheHashResults(
+        prefixes, cache_results, base::TimeDelta::FromMinutes(60));
+  }
+
+  {
+    // Check if DB contains (prefix 1001, suffix 01). Should return false, since
+    // we have a cached miss for that prefix.
+    std::vector<SBFullHash> full_hashes;
+    full_hashes.push_back(SBFullHashForPrefixAndSuffix(1001, "\x01"));
+    std::vector<SBPrefix> prefix_hits;
+    std::vector<SBFullHashResult> cache_hits;
+    EXPECT_FALSE(
+        ContainsBrowseUrlHashes(&full_hashes, &prefix_hits, &cache_hits));
+    EXPECT_TRUE(prefix_hits.empty());
+    EXPECT_TRUE(cache_hits.empty());
+
+    // Add (1002,01) to search. Should return a prefix hit for 1002 only.
+    full_hashes.push_back(SBFullHashForPrefixAndSuffix(1002, "\x01"));
+    prefix_hits.clear();
+    cache_hits.clear();
+    EXPECT_TRUE(
+        ContainsBrowseUrlHashes(&full_hashes, &prefix_hits, &cache_hits));
+    ASSERT_EQ(1U, prefix_hits.size());
+    EXPECT_EQ(1002U, prefix_hits[0]);
+    EXPECT_TRUE(cache_hits.empty());
+  }
+}
+
+TEST_F(SafeBrowsingDatabaseTest, TestCachedPrefixHitFullMiss) {
+  std::vector<SBListChunkRanges> lists;
+  ASSERT_TRUE(database_->UpdateStarted(&lists));
+
+  SBChunkList chunks;
+  {
+    // Insert prefix 1001 into database.
+    SBChunk chunk;
+    InsertAddChunkHostPrefixValue(&chunk, 1, SBPrefix(100), SBPrefix(1001));
+    chunks.push_back(chunk);
+  }
+  {
+    // Insert prefix 1002 into database.
+    SBChunk chunk;
+    InsertAddChunkHostPrefixValue(&chunk, 2, SBPrefix(101), SBPrefix(1002));
+    chunks.push_back(chunk);
+  }
+
+  database_->InsertChunks(safe_browsing_util::kMalwareList, chunks);
+  database_->UpdateFinished(true);
+
+  {
+    // Check if DB contains (prefix 1001, suffix 01). Should return a prefix
+    // hit.
+    std::vector<SBFullHash> full_hashes;
+    full_hashes.push_back(SBFullHashForPrefixAndSuffix(1001, "\x01"));
+    std::vector<SBPrefix> prefix_hits;
+    std::vector<SBFullHashResult> cache_hits;
+    EXPECT_TRUE(
+        ContainsBrowseUrlHashes(&full_hashes, &prefix_hits, &cache_hits));
+    ASSERT_EQ(1U, prefix_hits.size());
+    EXPECT_EQ(1001U, prefix_hits[0]);
+    EXPECT_TRUE(cache_hits.empty());
+
+    // Add (1002,01) to search. Should return a prefix hit for both 1001 and
+    // 1002.
+    full_hashes.push_back(SBFullHashForPrefixAndSuffix(1002, "\x01"));
+    prefix_hits.clear();
+    cache_hits.clear();
+    EXPECT_TRUE(
+        ContainsBrowseUrlHashes(&full_hashes, &prefix_hits, &cache_hits));
+    ASSERT_EQ(2U, prefix_hits.size());
+    EXPECT_EQ(1001U, prefix_hits[0]);
+    EXPECT_EQ(1002U, prefix_hits[1]);
+    EXPECT_TRUE(cache_hits.empty());
+
+    // Add (1003,01) to search. Should still return a prefix hit for both 1001
+    // and 1002.
+    full_hashes.push_back(SBFullHashForPrefixAndSuffix(1003, "\x01"));
+    prefix_hits.clear();
+    cache_hits.clear();
+    EXPECT_TRUE(
+        ContainsBrowseUrlHashes(&full_hashes, &prefix_hits, &cache_hits));
+    ASSERT_EQ(2U, prefix_hits.size());
+    EXPECT_EQ(1001U, prefix_hits[0]);
+    EXPECT_EQ(1002U, prefix_hits[1]);
+    EXPECT_TRUE(cache_hits.empty());
+  }
+
+  {
+    // Cache a fullhash result for (1001,01) and (1001,03).
+    std::vector<SBPrefix> prefixes;
+    prefixes.push_back(SBPrefix(1001));
+    std::vector<SBFullHashResult> cache_results;
+
+    SBFullHashResult full_hash_result;
+    full_hash_result.hash = SBFullHashForPrefixAndSuffix(1001, "\x01");
+    full_hash_result.list_name = safe_browsing_util::kMalwareList;
+    cache_results.push_back(full_hash_result);
+
+    full_hash_result.hash = SBFullHashForPrefixAndSuffix(1001, "\x03");
+    cache_results.push_back(full_hash_result);
+
+    database_->CacheHashResults(
+        prefixes, cache_results, base::TimeDelta::FromMinutes(60));
+  }
+
+  {
+    // Check again if DB contains (prefix 1001, suffix 01). Should return a
+    // cache hit now.
+    std::vector<SBFullHash> full_hashes;
+    full_hashes.push_back(SBFullHashForPrefixAndSuffix(1001, "\x01"));
+    std::vector<SBPrefix> prefix_hits;
+    std::vector<SBFullHashResult> cache_hits;
+    EXPECT_TRUE(
+        ContainsBrowseUrlHashes(&full_hashes, &prefix_hits, &cache_hits));
+    EXPECT_TRUE(prefix_hits.empty());
+    ASSERT_EQ(1U, cache_hits.size());
+    EXPECT_TRUE(SBFullHashEqual(SBFullHashForPrefixAndSuffix(1001, "\x01"),
+                                cache_hits[0].hash));
+
+    // Add (1002,01) to search. Should return a cache hit for 1001 and prefix
+    // hit for 1002.
+    full_hashes.push_back(SBFullHashForPrefixAndSuffix(1002, "\x01"));
+    prefix_hits.clear();
+    cache_hits.clear();
+    EXPECT_TRUE(
+        ContainsBrowseUrlHashes(&full_hashes, &prefix_hits, &cache_hits));
+    ASSERT_EQ(1U, prefix_hits.size());
+    EXPECT_EQ(1002U, prefix_hits[0]);
+    ASSERT_EQ(1U, cache_hits.size());
+    EXPECT_TRUE(SBFullHashEqual(SBFullHashForPrefixAndSuffix(1001, "\x01"),
+                                cache_hits[0].hash));
+
+    // Add (1001,03) to search. Should return 2 cache hits for 1001 and a prefix
+    // hit for 1002.
+    full_hashes.push_back(SBFullHashForPrefixAndSuffix(1001, "\x03"));
+    prefix_hits.clear();
+    cache_hits.clear();
+    EXPECT_TRUE(
+        ContainsBrowseUrlHashes(&full_hashes, &prefix_hits, &cache_hits));
+    ASSERT_EQ(1U, prefix_hits.size());
+    EXPECT_EQ(1002U, prefix_hits[0]);
+    ASSERT_EQ(2U, cache_hits.size());
+    EXPECT_TRUE(SBFullHashEqual(SBFullHashForPrefixAndSuffix(1001, "\x01"),
+                                cache_hits[0].hash));
+    EXPECT_TRUE(SBFullHashEqual(SBFullHashForPrefixAndSuffix(1001, "\x03"),
+                                cache_hits[1].hash));
+  }
+
+  {
+    // Check if DB contains only (prefix 1001, suffix 03). Should return a cache
+    // hit.
+    std::vector<SBFullHash> full_hashes;
+    full_hashes.push_back(SBFullHashForPrefixAndSuffix(1001, "\x03"));
+    std::vector<SBPrefix> prefix_hits;
+    std::vector<SBFullHashResult> cache_hits;
+    EXPECT_TRUE(
+        ContainsBrowseUrlHashes(&full_hashes, &prefix_hits, &cache_hits));
+    EXPECT_TRUE(prefix_hits.empty());
+    ASSERT_EQ(1U, cache_hits.size());
+    EXPECT_TRUE(SBFullHashEqual(SBFullHashForPrefixAndSuffix(1001, "\x03"),
+                                cache_hits[0].hash));
+  }
+
+  {
+    // Check if DB contains (prefix 1001, suffix 02). Should return false, since
+    // we have a cached fullhash for that prefix but which does not match the
+    // fullhash.
+    std::vector<SBFullHash> full_hashes;
+    full_hashes.push_back(SBFullHashForPrefixAndSuffix(1001, "\x02"));
+    std::vector<SBPrefix> prefix_hits;
+    std::vector<SBFullHashResult> cache_hits;
+    EXPECT_FALSE(
+        ContainsBrowseUrlHashes(&full_hashes, &prefix_hits, &cache_hits));
+    EXPECT_TRUE(prefix_hits.empty());
+    EXPECT_TRUE(cache_hits.empty());
+
+    // Add (1002,01) to search. Should return a prefix hit for 1002.
+    full_hashes.push_back(SBFullHashForPrefixAndSuffix(1002, "\x01"));
+    prefix_hits.clear();
+    cache_hits.clear();
+    EXPECT_TRUE(
+        ContainsBrowseUrlHashes(&full_hashes, &prefix_hits, &cache_hits));
+    ASSERT_EQ(1U, prefix_hits.size());
+    EXPECT_EQ(1002U, prefix_hits[0]);
+    EXPECT_TRUE(cache_hits.empty());
+  }
+}
+
+TEST_F(SafeBrowsingDatabaseTest, TestBrowseFullHashMatching) {
+  std::vector<SBListChunkRanges> lists;
+  ASSERT_TRUE(database_->UpdateStarted(&lists));
+
+  SBChunkList chunks;
+  {
+    // Insert fullhash (1001,1) into database.
+    SBChunk chunk;
+    InsertAddChunkHostFullHashValue(
+        &chunk, 1, SBPrefix(100), SBFullHashForPrefixAndSuffix(1001, "\x01"));
+    chunks.push_back(chunk);
+  }
+  {
+    // Insert fullhash (1001,2) into database.
+    SBChunk chunk;
+    InsertAddChunkHostFullHashValue(
+        &chunk, 2, SBPrefix(100), SBFullHashForPrefixAndSuffix(1001, "\x02"));
+    chunks.push_back(chunk);
+  }
+
+  database_->InsertChunks(safe_browsing_util::kMalwareList, chunks);
+  database_->UpdateFinished(true);
+
+  {
+    // Check if DB contains (prefix 1001, suffix 03). Should return false,
+    // since the DB contains a matching prefix but the full hashes do not match.
+    std::vector<SBFullHash> full_hashes;
+    full_hashes.push_back(SBFullHashForPrefixAndSuffix(1001, "\x03"));
+    std::vector<SBPrefix> prefix_hits;
+    std::vector<SBFullHashResult> cache_hits;
+    EXPECT_FALSE(
+        ContainsBrowseUrlHashes(&full_hashes, &prefix_hits, &cache_hits));
+    EXPECT_TRUE(prefix_hits.empty());
+    EXPECT_TRUE(cache_hits.empty());
+
+    // Add (1001,1). Should now return a prefix hit.
+    full_hashes.push_back(SBFullHashForPrefixAndSuffix(1001, "\x01"));
+    prefix_hits.clear();
+    cache_hits.clear();
+    EXPECT_TRUE(
+        ContainsBrowseUrlHashes(&full_hashes, &prefix_hits, &cache_hits));
+    ASSERT_EQ(1U, prefix_hits.size());
+    EXPECT_EQ(1001U, prefix_hits[0]);
+    EXPECT_TRUE(cache_hits.empty());
+
+    // Add (1001,2). Should still return a single prefix hit.
+    full_hashes.push_back(SBFullHashForPrefixAndSuffix(1001, "\x02"));
+    prefix_hits.clear();
+    cache_hits.clear();
+    EXPECT_TRUE(
+        ContainsBrowseUrlHashes(&full_hashes, &prefix_hits, &cache_hits));
+    ASSERT_EQ(1U, prefix_hits.size());
+    EXPECT_EQ(1001U, prefix_hits[0]);
+    EXPECT_TRUE(cache_hits.empty());
+  }
+
+  {
+    // Check if DB contains (prefix 1001, suffix 02) alone. Should return a
+    // prefix hit.
+    std::vector<SBFullHash> full_hashes;
+    full_hashes.push_back(SBFullHashForPrefixAndSuffix(1001, "\x02"));
+    std::vector<SBPrefix> prefix_hits;
+    std::vector<SBFullHashResult> cache_hits;
+    EXPECT_TRUE(
+        ContainsBrowseUrlHashes(&full_hashes, &prefix_hits, &cache_hits));
+    ASSERT_EQ(1U, prefix_hits.size());
+    EXPECT_EQ(1001U, prefix_hits[0]);
+    EXPECT_TRUE(cache_hits.empty());
+  }
+
+  {
+    // Cache a fullhash result for (prefix 1001, suffix 02).
+    std::vector<SBPrefix> prefixes;
+    prefixes.push_back(SBPrefix(1001));
+    std::vector<SBFullHashResult> cache_results;
+
+    SBFullHashResult full_hash_result;
+    full_hash_result.hash = SBFullHashForPrefixAndSuffix(1001, "\x02");
+    full_hash_result.list_name = safe_browsing_util::kMalwareList;
+
+    cache_results.push_back(full_hash_result);
+
+    database_->CacheHashResults(
+        prefixes, cache_results, base::TimeDelta::FromMinutes(60));
+  }
+
+  {
+    // Check if DB contains (prefix 1001, suffix 03). Should return false,
+    // since the DB contains a cached hit with matching prefix but not
+    // matching the fullhash.
+    std::vector<SBFullHash> full_hashes;
+    full_hashes.push_back(SBFullHashForPrefixAndSuffix(1001, "\x03"));
+    std::vector<SBPrefix> prefix_hits;
+    std::vector<SBFullHashResult> cache_hits;
+    EXPECT_FALSE(
+        ContainsBrowseUrlHashes(&full_hashes, &prefix_hits, &cache_hits));
+    EXPECT_TRUE(prefix_hits.empty());
+    EXPECT_TRUE(cache_hits.empty());
+
+    // Add (1001,1). Should still return false.
+    full_hashes.push_back(SBFullHashForPrefixAndSuffix(1001, "\x01"));
+    prefix_hits.clear();
+    cache_hits.clear();
+    EXPECT_FALSE(
+        ContainsBrowseUrlHashes(&full_hashes, &prefix_hits, &cache_hits));
+    EXPECT_TRUE(prefix_hits.empty());
+    EXPECT_TRUE(cache_hits.empty());
+
+    // Add (1001,2). Should now return a cache hit.
+    full_hashes.push_back(SBFullHashForPrefixAndSuffix(1001, "\x02"));
+    prefix_hits.clear();
+    cache_hits.clear();
+    EXPECT_TRUE(
+        ContainsBrowseUrlHashes(&full_hashes, &prefix_hits, &cache_hits));
+    EXPECT_TRUE(prefix_hits.empty());
+    ASSERT_EQ(1U, cache_hits.size());
+    EXPECT_TRUE(SBFullHashEqual(SBFullHashForPrefixAndSuffix(1001, "\x02"),
+                                cache_hits[0].hash));
+  }
+
+  ASSERT_TRUE(database_->UpdateStarted(&lists));
+  chunks.clear();
+  {
+    // Sub fullhash (1001,1) from database.
+    SBChunk chunk;
+    InsertSubChunkHostFullHashValue(&chunk,
+                                    11,
+                                    1,
+                                    SBPrefix(100),
+                                    SBFullHashForPrefixAndSuffix(1001, "\x01"));
+    chunks.push_back(chunk);
+  }
+  database_->InsertChunks(safe_browsing_util::kMalwareList, chunks);
+  database_->UpdateFinished(true);
+
+  {
+    // Check if DB contains (prefix 1001, suffix 01). Should return false,
+    // since it was just subbed.
+    std::vector<SBFullHash> full_hashes;
+    full_hashes.push_back(SBFullHashForPrefixAndSuffix(1001, "\x01"));
+    std::vector<SBPrefix> prefix_hits;
+    std::vector<SBFullHashResult> cache_hits;
+    EXPECT_FALSE(
+        ContainsBrowseUrlHashes(&full_hashes, &prefix_hits, &cache_hits));
+    EXPECT_TRUE(prefix_hits.empty());
+    EXPECT_TRUE(cache_hits.empty());
+
+    // Add (1001,3). Should still return false.
+    full_hashes.push_back(SBFullHashForPrefixAndSuffix(1001, "\x03"));
+    prefix_hits.clear();
+    cache_hits.clear();
+    EXPECT_FALSE(
+        ContainsBrowseUrlHashes(&full_hashes, &prefix_hits, &cache_hits));
+    EXPECT_TRUE(prefix_hits.empty());
+    EXPECT_TRUE(cache_hits.empty());
+
+    // Add (1001,2). Should now return a prefix hit.
+    full_hashes.push_back(SBFullHashForPrefixAndSuffix(1001, "\x02"));
+    prefix_hits.clear();
+    cache_hits.clear();
+    EXPECT_TRUE(
+        ContainsBrowseUrlHashes(&full_hashes, &prefix_hits, &cache_hits));
+    ASSERT_EQ(1U, prefix_hits.size());
+    EXPECT_EQ(1001U, prefix_hits[0]);
+    EXPECT_TRUE(cache_hits.empty());
+  }
+
+  ASSERT_TRUE(database_->UpdateStarted(&lists));
+  chunks.clear();
+  {
+    // Sub fullhash (1001,2) from database.
+    SBChunk chunk;
+    InsertSubChunkHostFullHashValue(&chunk,
+                                    12,
+                                    2,
+                                    SBPrefix(100),
+                                    SBFullHashForPrefixAndSuffix(1001, "\x02"));
+    chunks.push_back(chunk);
+  }
+  database_->InsertChunks(safe_browsing_util::kMalwareList, chunks);
+  database_->UpdateFinished(true);
+
+  {
+    // Check if DB contains (prefix 1001, suffix 01). Should return false,
+    // since it was just subbed.
+    std::vector<SBFullHash> full_hashes;
+    full_hashes.push_back(SBFullHashForPrefixAndSuffix(1001, "\x01"));
+    std::vector<SBPrefix> prefix_hits;
+    std::vector<SBFullHashResult> cache_hits;
+    EXPECT_FALSE(
+        ContainsBrowseUrlHashes(&full_hashes, &prefix_hits, &cache_hits));
+    EXPECT_TRUE(prefix_hits.empty());
+    EXPECT_TRUE(cache_hits.empty());
+
+    // Add (1001,3). Should still return false.
+    full_hashes.push_back(SBFullHashForPrefixAndSuffix(1001, "\x03"));
+    prefix_hits.clear();
+    cache_hits.clear();
+    EXPECT_FALSE(
+        ContainsBrowseUrlHashes(&full_hashes, &prefix_hits, &cache_hits));
+    EXPECT_TRUE(prefix_hits.empty());
+    EXPECT_TRUE(cache_hits.empty());
+
+    // Add (1001,2). Should still return false.
+    full_hashes.push_back(SBFullHashForPrefixAndSuffix(1001, "\x02"));
+    prefix_hits.clear();
+    cache_hits.clear();
+    EXPECT_FALSE(
+        ContainsBrowseUrlHashes(&full_hashes, &prefix_hits, &cache_hits));
+    EXPECT_TRUE(prefix_hits.empty());
+    EXPECT_TRUE(cache_hits.empty());
+  }
+}
+
+TEST_F(SafeBrowsingDatabaseTest, TestBrowseAddFullHashAddPrefix) {
+  std::vector<SBListChunkRanges> lists;
+
+  // Update 1: add a fullhash.
+  ASSERT_TRUE(database_->UpdateStarted(&lists));
+  SBChunkList chunks;
+  {
+    SBChunk chunk;
+    InsertAddChunkHostFullHashValue(
+        &chunk, 1, SBPrefix(100), SBFullHashForPrefixAndSuffix(1001, "\x01"));
+    chunks.push_back(chunk);
+  }
+  database_->InsertChunks(safe_browsing_util::kMalwareList, chunks);
+  database_->UpdateFinished(true);
+
+  // Update 2: add same prefix.
+  ASSERT_TRUE(database_->UpdateStarted(&lists));
+  chunks.clear();
+  {
+    SBChunk chunk;
+    InsertAddChunkHostPrefixValue(
+        &chunk, 2, SBPrefix(100), SBPrefix(1001));
+    chunks.push_back(chunk);
+  }
+  database_->InsertChunks(safe_browsing_util::kMalwareList, chunks);
+  database_->UpdateFinished(true);
+
+  {
+    // Check if DB contains (prefix 1001, suffix 02). Should return true,
+    // since we added the prefix.
+    std::vector<SBFullHash> full_hashes;
+    full_hashes.push_back(SBFullHashForPrefixAndSuffix(1001, "\x02"));
+    std::vector<SBPrefix> prefix_hits;
+    std::vector<SBFullHashResult> cache_hits;
+    EXPECT_TRUE(
+        ContainsBrowseUrlHashes(&full_hashes, &prefix_hits, &cache_hits));
+    ASSERT_EQ(1U, prefix_hits.size());
+    EXPECT_EQ(1001U, prefix_hits[0]);
+    EXPECT_TRUE(cache_hits.empty());
+  }
+
+  // Update 3: sub the fullhash.
+  ASSERT_TRUE(database_->UpdateStarted(&lists));
+  chunks.clear();
+  {
+    // Sub fullhash (1001,1) from database.
+    SBChunk chunk;
+    InsertSubChunkHostFullHashValue(&chunk,
+                                    12,
+                                    2,
+                                    SBPrefix(100),
+                                    SBFullHashForPrefixAndSuffix(1001, "\x01"));
+    chunks.push_back(chunk);
+  }
+  database_->InsertChunks(safe_browsing_util::kMalwareList, chunks);
+  database_->UpdateFinished(true);
+
+  {
+    // Check if DB contains (prefix 1001, suffix 02). Should still return true,
+    // since we added the prefix.
+    std::vector<SBFullHash> full_hashes;
+    full_hashes.push_back(SBFullHashForPrefixAndSuffix(1001, "\x02"));
+    std::vector<SBPrefix> prefix_hits;
+    std::vector<SBFullHashResult> cache_hits;
+    EXPECT_TRUE(
+        ContainsBrowseUrlHashes(&full_hashes, &prefix_hits, &cache_hits));
+    ASSERT_EQ(1U, prefix_hits.size());
+    EXPECT_EQ(1001U, prefix_hits[0]);
+    EXPECT_TRUE(cache_hits.empty());
+  }
+}
+
 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,
                                               NULL,
                                               NULL,
                                               ip_blacklist_store));
   database_->Init(database_filename_);
   std::vector<SBListChunkRanges> lists;
-  EXPECT_TRUE(database_->UpdateStarted(&lists));
+  ASSERT_TRUE(database_->UpdateStarted(&lists));
 
   // IPv4 prefix match for ::ffff:192.168.1.0/120.
   SBChunkList chunks;
   SBChunk chunk;
   InsertAddChunkFullHash(&chunk, 1, "::ffff:192.168.1.0", 120);
   chunks.push_back(chunk);
   database_->InsertChunks(safe_browsing_util::kIPBlacklist, chunks);
 
   // IPv4 exact match for ::ffff:192.1.1.1.
   chunks.clear();
@@ skipping 63 matching lines @@
   EXPECT_FALSE(database_->ContainsMalwareIP("192.1.124.0"));
 
   EXPECT_FALSE(database_->ContainsMalwareIP("192.1.127.255"));
   EXPECT_TRUE(database_->ContainsMalwareIP("192.1.128.0"));
   EXPECT_TRUE(database_->ContainsMalwareIP("::ffff:192.1.128.1"));
   EXPECT_TRUE(database_->ContainsMalwareIP("192.1.128.255"));
   EXPECT_TRUE(database_->ContainsMalwareIP("192.1.255.0"));
   EXPECT_TRUE(database_->ContainsMalwareIP("192.1.255.255"));
   EXPECT_FALSE(database_->ContainsMalwareIP("192.2.0.0"));
 }