Only call UrlToFullHashes once from LocalSafeBrowsingDatabaseManager::CheckBrowseUrl

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 <stddef.h>
 #include <utility>
@@ skipping 459 matching lines @@
   EXPECT_TRUE(lists[7].subs.empty());
   EXPECT_EQ(kUnwantedUrlList, lists[8].name);
   EXPECT_EQ("11", lists[8].adds);
   EXPECT_TRUE(lists[8].subs.empty());
 
   database_.reset();
 }
 
 // Checks database reading and writing for browse and unwanted PrefixSets.
 TEST_F(SafeBrowsingDatabaseTest, BrowseAndUnwantedDatabasesAndPrefixSets) {
+
   struct TestCase {
     using TestListContainsBadUrl = bool (SafeBrowsingDatabase::*)(
         const GURL& url,
         std::vector<SBPrefix>* prefix_hits,
         std::vector<SBFullHashResult>* cache_hits);
+    using TestListContainsBadHashes = bool (SafeBrowsingDatabase::*)(
+        const std::vector<SBFullHash>& full_hashes,
+        std::vector<SBPrefix>* prefix_hits,
+        std::vector<SBFullHashResult>* cache_hits);
 
     const char* test_list_name;
     size_t expected_list_index;
     TestListContainsBadUrl test_list_contains_bad_url;
-  } const kTestCases[]{
-      {kMalwareList, 0U, &SafeBrowsingDatabase::ContainsBrowseUrl},
-      {kPhishingList, 1U, &SafeBrowsingDatabase::ContainsBrowseUrl},
-      {kUnwantedUrlList, 8U,
-       &SafeBrowsingDatabase::ContainsUnwantedSoftwareUrl},
+    TestListContainsBadHashes test_list_contains_bad_hashes;
+
+    void TestContainsFunctions(SafeBrowsingDatabaseNew& database,
+        bool expected_outcome,
+        const GURL& url,
+        std::vector<SBPrefix>* prefix_hits,
+        std::vector<SBFullHashResult>* cache_hits) const {
+      EXPECT_EQ(expected_outcome,
+          (database.*test_list_contains_bad_url)(url, prefix_hits, cache_hits))
+          << test_list_name << url;
+
+      // Contains*Hashes should always return the same result as Contains*Url.
+      std::vector<SBFullHash> full_hashes;
+      UrlToFullHashes(url, false, &full_hashes);
+      ASSERT_FALSE(full_hashes.empty()) << test_list_name << url;
+
+      std::vector<SBPrefix> hash_prefix_hits;
+      std::vector<SBFullHashResult> hash_cache_hits;
+      EXPECT_EQ(expected_outcome, (database.*test_list_contains_bad_hashes)(
+          full_hashes, &hash_prefix_hits, &hash_cache_hits)) << test_list_name
+          << url;
+
+      EXPECT_EQ(prefix_hits->size(), hash_prefix_hits.size()) << test_list_name
+          << url;
+      EXPECT_EQ(cache_hits->size(), hash_cache_hits.size()) << test_list_name
+          << url;
+    }
+  };
+
+  TestCase const kTestCases[] {
+    {
+      kMalwareList,
+      0U,
+      &SafeBrowsingDatabase::ContainsBrowseUrl,
+      &SafeBrowsingDatabase::ContainsBrowseHashes
+    },
+    {
+      kPhishingList,
+      1U,
+      &SafeBrowsingDatabase::ContainsBrowseUrl,
+      &SafeBrowsingDatabase::ContainsBrowseHashes
+    },
+    {
+      kUnwantedUrlList,
+      8U,
+      &SafeBrowsingDatabase::ContainsUnwantedSoftwareUrl,
+      &SafeBrowsingDatabase::ContainsUnwantedSoftwareHashes
+    },
   };
 
   for (const auto& test_case : kTestCases) {
     SCOPED_TRACE(std::string("Tested list at fault => ") +
                  test_case.test_list_name);
 
     std::vector<SBListChunkRanges> lists;
     std::vector<scoped_ptr<SBChunkData>> chunks;
 
     chunks.push_back(AddChunkPrefix2Value(1,
@@ skipping 15 matching lines @@
     GetListsInfo(&lists);
 
     ASSERT_LE(1U, lists.size());
     EXPECT_EQ(test_case.test_list_name,
               lists[test_case.expected_list_index].name);
     EXPECT_EQ("1-3,7", lists[test_case.expected_list_index].adds);
     EXPECT_TRUE(lists[test_case.expected_list_index].subs.empty());
 
     std::vector<SBPrefix> prefix_hits;
     std::vector<SBFullHashResult> cache_hits;
-    EXPECT_TRUE((database_.get()->*test_case.test_list_contains_bad_url)(
-        GURL("http://www.evil.com/phishing.html"), &prefix_hits, &cache_hits));
+    test_case.TestContainsFunctions(*database_, true,
+        GURL("http://www.evil.com/phishing.html"), &prefix_hits, &cache_hits);
+
     ASSERT_EQ(1U, prefix_hits.size());
     EXPECT_EQ(SBPrefixForString("www.evil.com/phishing.html"), prefix_hits[0]);
     EXPECT_TRUE(cache_hits.empty());
 
-    EXPECT_TRUE((database_.get()->*test_case.test_list_contains_bad_url)(
-        GURL("http://www.evil.com/malware.html"), &prefix_hits, &cache_hits));
+    test_case.TestContainsFunctions(*database_, true,
+        GURL("http://www.evil.com/malware.html"), &prefix_hits, &cache_hits);
 
-    EXPECT_TRUE((database_.get()->*test_case.test_list_contains_bad_url)(
-        GURL("http://www.evil.com/notevil1.html"), &prefix_hits, &cache_hits));
+    test_case.TestContainsFunctions(*database_, true,
+        GURL("http://www.evil.com/notevil1.html"), &prefix_hits, &cache_hits);
 
-    EXPECT_TRUE((database_.get()->*test_case.test_list_contains_bad_url)(
-        GURL("http://www.evil.com/notevil2.html"), &prefix_hits, &cache_hits));
+    test_case.TestContainsFunctions(*database_, true,
+        GURL("http://www.evil.com/notevil2.html"), &prefix_hits, &cache_hits);
 
-    EXPECT_TRUE((database_.get()->*test_case.test_list_contains_bad_url)(
-        GURL("http://www.good.com/good1.html"), &prefix_hits, &cache_hits));
+    test_case.TestContainsFunctions(*database_, true,
+        GURL("http://www.good.com/good1.html"), &prefix_hits, &cache_hits);
 
-    EXPECT_TRUE((database_.get()->*test_case.test_list_contains_bad_url)(
-        GURL("http://www.good.com/good2.html"), &prefix_hits, &cache_hits));
+    test_case.TestContainsFunctions(*database_, true,
+        GURL("http://www.good.com/good2.html"), &prefix_hits, &cache_hits);
 
-    EXPECT_TRUE((database_.get()->*test_case.test_list_contains_bad_url)(
-        GURL("http://192.168.0.1/malware.html"), &prefix_hits, &cache_hits));
+    test_case.TestContainsFunctions(*database_, true,
+        GURL("http://192.168.0.1/malware.html"), &prefix_hits, &cache_hits);
 
-    EXPECT_FALSE((database_.get()->*test_case.test_list_contains_bad_url)(
-        GURL("http://www.evil.com/"), &prefix_hits, &cache_hits));
+    test_case.TestContainsFunctions(*database_, false,
+        GURL("http://www.evil.com/"), &prefix_hits, &cache_hits);
     EXPECT_TRUE(prefix_hits.empty());
     EXPECT_TRUE(cache_hits.empty());
 
-    EXPECT_FALSE((database_.get()->*test_case.test_list_contains_bad_url)(
-        GURL("http://www.evil.com/robots.txt"), &prefix_hits, &cache_hits));
+    test_case.TestContainsFunctions(*database_, false,
+        GURL("http://www.evil.com/robots.txt"), &prefix_hits, &cache_hits);
 
-    EXPECT_TRUE((database_.get()->*test_case.test_list_contains_bad_url)(
-        GURL("http://www.evil.com/evil.html"), &prefix_hits, &cache_hits));
+    test_case.TestContainsFunctions(*database_, true,
+        GURL("http://www.evil.com/evil.html"), &prefix_hits, &cache_hits);
     ASSERT_EQ(1U, prefix_hits.size());
     EXPECT_EQ(SBPrefixForString("www.evil.com/evil.html"), prefix_hits[0]);
 
     // Attempt to re-add the first chunk (should be a no-op).
     // see bug: http://code.google.com/p/chromium/issues/detail?id=4522
     chunks.clear();
     chunks.push_back(AddChunkPrefix2Value(1,
                                           "www.evil.com/phishing.html",
                                           "www.evil.com/malware.html"));
     ASSERT_TRUE(database_->UpdateStarted(&lists));
     database_->InsertChunks(test_case.test_list_name, chunks);
     database_->UpdateFinished(true);
 
     GetListsInfo(&lists);
     ASSERT_LE(1U, lists.size());
     EXPECT_EQ(test_case.test_list_name,
               lists[test_case.expected_list_index].name);
     EXPECT_EQ("1-3,7", lists[test_case.expected_list_index].adds);
     EXPECT_TRUE(lists[test_case.expected_list_index].subs.empty());
 
     // Test removing a single prefix from the add chunk.
     chunks.clear();
     chunks.push_back(SubChunkPrefixValue(4, "www.evil.com/notevil1.html", 2));
     ASSERT_TRUE(database_->UpdateStarted(&lists));
     database_->InsertChunks(test_case.test_list_name, chunks);
     database_->UpdateFinished(true);
 
-    EXPECT_TRUE((database_.get()->*test_case.test_list_contains_bad_url)(
-        GURL("http://www.evil.com/phishing.html"), &prefix_hits, &cache_hits));
+    test_case.TestContainsFunctions(*database_, true,
+        GURL("http://www.evil.com/phishing.html"), &prefix_hits, &cache_hits);
     ASSERT_EQ(1U, prefix_hits.size());
     EXPECT_EQ(SBPrefixForString("www.evil.com/phishing.html"), prefix_hits[0]);
     EXPECT_TRUE(cache_hits.empty());
 
-    EXPECT_FALSE((database_.get()->*test_case.test_list_contains_bad_url)(
-        GURL("http://www.evil.com/notevil1.html"), &prefix_hits, &cache_hits));
+    test_case.TestContainsFunctions(*database_, false,
+        GURL("http://www.evil.com/notevil1.html"), &prefix_hits, &cache_hits);
     EXPECT_TRUE(prefix_hits.empty());
     EXPECT_TRUE(cache_hits.empty());
 
-    EXPECT_TRUE((database_.get()->*test_case.test_list_contains_bad_url)(
-        GURL("http://www.evil.com/notevil2.html"), &prefix_hits, &cache_hits));
+    test_case.TestContainsFunctions(*database_, true,
+        GURL("http://www.evil.com/notevil2.html"), &prefix_hits, &cache_hits);
 
-    EXPECT_TRUE((database_.get()->*test_case.test_list_contains_bad_url)(
-        GURL("http://www.good.com/good1.html"), &prefix_hits, &cache_hits));
+    test_case.TestContainsFunctions(*database_, true,
+        GURL("http://www.good.com/good1.html"), &prefix_hits, &cache_hits);
 
-    EXPECT_TRUE((database_.get()->*test_case.test_list_contains_bad_url)(
-        GURL("http://www.good.com/good2.html"), &prefix_hits, &cache_hits));
+    test_case.TestContainsFunctions(*database_, true,
+        GURL("http://www.good.com/good2.html"), &prefix_hits, &cache_hits);
 
     GetListsInfo(&lists);
     ASSERT_LE(1U, lists.size());
     EXPECT_EQ(test_case.test_list_name,
               lists[test_case.expected_list_index].name);
     EXPECT_EQ("1-3,7", lists[test_case.expected_list_index].adds);
     EXPECT_EQ("4", lists[test_case.expected_list_index].subs);
 
     // Test the same sub chunk again.  This should be a no-op.
     // see bug: http://code.google.com/p/chromium/issues/detail?id=4522
     chunks.clear();
     chunks.push_back(SubChunkPrefixValue(4, "www.evil.com/notevil1.html", 2));
 
     ASSERT_TRUE(database_->UpdateStarted(&lists));
     database_->InsertChunks(test_case.test_list_name, chunks);
     database_->UpdateFinished(true);
 
     GetListsInfo(&lists);
     ASSERT_LE(1U, lists.size());
     EXPECT_EQ(test_case.test_list_name,
               lists[test_case.expected_list_index].name);
     EXPECT_EQ("1-3,7", lists[test_case.expected_list_index].adds);
     EXPECT_EQ("4", lists[test_case.expected_list_index].subs);
 
     // Test removing all the prefixes from an add chunk.
     ASSERT_TRUE(database_->UpdateStarted(&lists));
     AddDelChunk(test_case.test_list_name, 2);
     database_->UpdateFinished(true);
 
-    EXPECT_FALSE((database_.get()->*test_case.test_list_contains_bad_url)(
-        GURL("http://www.evil.com/notevil2.html"), &prefix_hits, &cache_hits));
+    test_case.TestContainsFunctions(*database_, false,
+        GURL("http://www.evil.com/notevil2.html"), &prefix_hits, &cache_hits);
 
-    EXPECT_FALSE((database_.get()->*test_case.test_list_contains_bad_url)(
-        GURL("http://www.good.com/good1.html"), &prefix_hits, &cache_hits));
+    test_case.TestContainsFunctions(*database_, false,
+        GURL("http://www.good.com/good1.html"), &prefix_hits, &cache_hits);
 
-    EXPECT_FALSE((database_.get()->*test_case.test_list_contains_bad_url)(
-        GURL("http://www.good.com/good2.html"), &prefix_hits, &cache_hits));
+    test_case.TestContainsFunctions(*database_, false,
+        GURL("http://www.good.com/good2.html"), &prefix_hits, &cache_hits);
 
     GetListsInfo(&lists);
     ASSERT_LE(1U, lists.size());
     EXPECT_EQ(test_case.test_list_name,
               lists[test_case.expected_list_index].name);
     EXPECT_EQ("1,3,7", lists[test_case.expected_list_index].adds);
     EXPECT_EQ("4", lists[test_case.expected_list_index].subs);
 
     // 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
@@ skipping 22 matching lines @@
     chunks.clear();
     chunks.push_back(SubChunkPrefix2Value(5,
                                           "www.notevilanymore.com/index.html",
                                           10,
                                           "www.notevilanymore.com/good.html",
                                           10));
     ASSERT_TRUE(database_->UpdateStarted(&lists));
     database_->InsertChunks(test_case.test_list_name, chunks);
     database_->UpdateFinished(true);
 
-    EXPECT_FALSE((database_.get()->*test_case.test_list_contains_bad_url)(
+    test_case.TestContainsFunctions(*database_, false,
         GURL("http://www.notevilanymore.com/index.html"),
         &prefix_hits,
-        &cache_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.
     chunks.clear();
     chunks.push_back(AddChunkPrefix2Value(10,
                                           "www.notevilanymore.com/index.html",
                                           "www.notevilanymore.com/good.html"));
     ASSERT_TRUE(database_->UpdateStarted(&lists));
     database_->InsertChunks(test_case.test_list_name, chunks);
     database_->UpdateFinished(true);
 
-    EXPECT_FALSE((database_.get()->*test_case.test_list_contains_bad_url)(
+    test_case.TestContainsFunctions(*database_, false,
         GURL("http://www.notevilanymore.com/index.html"),
         &prefix_hits,
-        &cache_hits));
+        &cache_hits);
 
-    EXPECT_FALSE((database_.get()->*test_case.test_list_contains_bad_url)(
+    test_case.TestContainsFunctions(*database_, false,
         GURL("http://www.notevilanymore.com/good.html"),
         &prefix_hits,
-        &cache_hits));
+        &cache_hits);
 
     // Reset and reload the database.  The database will rely on the prefix set.
     ResetAndReloadFullDatabase();
 
     // Check that a prefix still hits.
-    EXPECT_TRUE((database_.get()->*test_case.test_list_contains_bad_url)(
-        GURL("http://www.evil.com/phishing.html"), &prefix_hits, &cache_hits));
+    test_case.TestContainsFunctions(*database_, true,
+        GURL("http://www.evil.com/phishing.html"), &prefix_hits, &cache_hits);
     ASSERT_EQ(1U, prefix_hits.size());
     EXPECT_EQ(SBPrefixForString("www.evil.com/phishing.html"), prefix_hits[0]);
 
     // Also check that it's not just always returning true in this case.
-    EXPECT_FALSE((database_.get()->*test_case.test_list_contains_bad_url)(
-        GURL("http://www.evil.com/"), &prefix_hits, &cache_hits));
+    test_case.TestContainsFunctions(*database_, false,
+        GURL("http://www.evil.com/"), &prefix_hits, &cache_hits);
 
     // Check that the full hash is still present.
-    EXPECT_TRUE((database_.get()->*test_case.test_list_contains_bad_url)(
-        GURL("http://www.evil.com/evil.html"), &prefix_hits, &cache_hits));
+    test_case.TestContainsFunctions(*database_, true,
+        GURL("http://www.evil.com/evil.html"), &prefix_hits, &cache_hits);
     ASSERT_EQ(1U, prefix_hits.size());
     EXPECT_EQ(SBPrefixForString("www.evil.com/evil.html"), prefix_hits[0]);
   }
 }
 
 // Test adding zero length chunks to the database.
 TEST_F(SafeBrowsingDatabaseTest, ZeroSizeChunk) {
   std::vector<SBListChunkRanges> lists;
   std::vector<scoped_ptr<SBChunkData>> chunks;
 
@@ skipping 967 matching lines @@
     std::vector<SBFullHashResult> cache_results;
     database_->CacheHashResults(prefixes, cache_results, kCacheLifetime);
   }
 
   {
     // kFullHash1_1 gets no prefix hit because of the cached item, and also does
     // not have a cache hit.
     std::vector<SBFullHash> full_hashes(1, kFullHash1_1);
     std::vector<SBPrefix> prefix_hits;
     std::vector<SBFullHashResult> cache_hits;
-    EXPECT_FALSE(database_->ContainsBrowseUrlHashesForTesting(
+    EXPECT_FALSE(database_->ContainsBrowseHashes(
         full_hashes, &prefix_hits, &cache_hits));
 
     // kFullHash2_1 gets a hit from the prefix in the database.
     full_hashes.push_back(kFullHash2_1);
     prefix_hits.clear();
     cache_hits.clear();
-    EXPECT_TRUE(database_->ContainsBrowseUrlHashesForTesting(
+    EXPECT_TRUE(database_->ContainsBrowseHashes(
         full_hashes, &prefix_hits, &cache_hits));
     ASSERT_EQ(1U, prefix_hits.size());
     EXPECT_EQ(kPrefix2, prefix_hits[0]);
     EXPECT_TRUE(cache_hits.empty());
   }
 }
 
 TEST_F(SafeBrowsingDatabaseTest, CachedPrefixHitFullMiss) {
   const SBPrefix kPrefix1 = 1001U;
   const SBFullHash kFullHash1_1 =
@@ skipping 20 matching lines @@
   ASSERT_TRUE(database_->UpdateStarted(&lists));
   database_->InsertChunks(kMalwareList, chunks);
   database_->UpdateFinished(true);
 
   {
     // kFullHash1_1 has a prefix hit of kPrefix1.
     std::vector<SBFullHash> full_hashes;
     full_hashes.push_back(kFullHash1_1);
     std::vector<SBPrefix> prefix_hits;
     std::vector<SBFullHashResult> cache_hits;
-    EXPECT_TRUE(database_->ContainsBrowseUrlHashesForTesting(
+    EXPECT_TRUE(database_->ContainsBrowseHashes(
         full_hashes, &prefix_hits, &cache_hits));
     ASSERT_EQ(1U, prefix_hits.size());
     EXPECT_EQ(kPrefix1, prefix_hits[0]);
     EXPECT_TRUE(cache_hits.empty());
 
     // kFullHash2_1 has a prefix hit of kPrefix2.
     full_hashes.push_back(kFullHash2_1);
     prefix_hits.clear();
     cache_hits.clear();
-    EXPECT_TRUE(database_->ContainsBrowseUrlHashesForTesting(
+    EXPECT_TRUE(database_->ContainsBrowseHashes(
         full_hashes, &prefix_hits, &cache_hits));
     ASSERT_EQ(2U, prefix_hits.size());
     EXPECT_EQ(kPrefix1, prefix_hits[0]);
     EXPECT_EQ(kPrefix2, prefix_hits[1]);
     EXPECT_TRUE(cache_hits.empty());
 
     // kFullHash3_1 has no hits.
     full_hashes.push_back(kFullHash3_1);
     prefix_hits.clear();
     cache_hits.clear();
-    EXPECT_TRUE(database_->ContainsBrowseUrlHashesForTesting(
+    EXPECT_TRUE(database_->ContainsBrowseHashes(
         full_hashes, &prefix_hits, &cache_hits));
     ASSERT_EQ(2U, prefix_hits.size());
     EXPECT_EQ(kPrefix1, prefix_hits[0]);
     EXPECT_EQ(kPrefix2, prefix_hits[1]);
     EXPECT_TRUE(cache_hits.empty());
   }
 
   {
     // Cache a fullhash result for two kPrefix1 full hashes.
     std::vector<SBPrefix> prefixes(1, kPrefix1);
     std::vector<SBFullHashResult> cache_results;
 
     SBFullHashResult full_hash_result;
     full_hash_result.list_id = MALWARE;
 
     full_hash_result.hash = kFullHash1_1;
     cache_results.push_back(full_hash_result);
 
     full_hash_result.hash = kFullHash1_3;
     cache_results.push_back(full_hash_result);
 
     database_->CacheHashResults(prefixes, cache_results, kCacheLifetime);
   }
 
   {
     // kFullHash1_1 should now see a cache hit.
     std::vector<SBFullHash> full_hashes(1, kFullHash1_1);
     std::vector<SBPrefix> prefix_hits;
     std::vector<SBFullHashResult> cache_hits;
-    EXPECT_TRUE(database_->ContainsBrowseUrlHashesForTesting(
+    EXPECT_TRUE(database_->ContainsBrowseHashes(
         full_hashes, &prefix_hits, &cache_hits));
     EXPECT_TRUE(prefix_hits.empty());
     ASSERT_EQ(1U, cache_hits.size());
     EXPECT_TRUE(SBFullHashEqual(
         kFullHash1_1, cache_hits[0].hash));
 
     // Adding kFullHash2_1 will see the existing cache hit plus the prefix hit
     // for kPrefix2.
     full_hashes.push_back(kFullHash2_1);
     prefix_hits.clear();
     cache_hits.clear();
-    EXPECT_TRUE(database_->ContainsBrowseUrlHashesForTesting(
+    EXPECT_TRUE(database_->ContainsBrowseHashes(
         full_hashes, &prefix_hits, &cache_hits));
     ASSERT_EQ(1U, prefix_hits.size());
     EXPECT_EQ(kPrefix2, prefix_hits[0]);
     ASSERT_EQ(1U, cache_hits.size());
     EXPECT_TRUE(SBFullHashEqual(
         kFullHash1_1, cache_hits[0].hash));
 
     // kFullHash1_3 also gets a cache hit.
     full_hashes.push_back(kFullHash1_3);
     prefix_hits.clear();
     cache_hits.clear();
-    EXPECT_TRUE(database_->ContainsBrowseUrlHashesForTesting(
+    EXPECT_TRUE(database_->ContainsBrowseHashes(
         full_hashes, &prefix_hits, &cache_hits));
     ASSERT_EQ(1U, prefix_hits.size());
     EXPECT_EQ(kPrefix2, prefix_hits[0]);
     ASSERT_EQ(2U, cache_hits.size());
     EXPECT_TRUE(SBFullHashEqual(
         kFullHash1_1, cache_hits[0].hash));
     EXPECT_TRUE(SBFullHashEqual(
         kFullHash1_3, cache_hits[1].hash));
   }
 
   {
     // Check if DB contains only kFullHash1_3. Should return a cache hit.
     std::vector<SBFullHash> full_hashes(1, kFullHash1_3);
     std::vector<SBPrefix> prefix_hits;
     std::vector<SBFullHashResult> cache_hits;
-    EXPECT_TRUE(database_->ContainsBrowseUrlHashesForTesting(
+    EXPECT_TRUE(database_->ContainsBrowseHashes(
         full_hashes, &prefix_hits, &cache_hits));
     EXPECT_TRUE(prefix_hits.empty());
     ASSERT_EQ(1U, cache_hits.size());
     EXPECT_TRUE(SBFullHashEqual(
         kFullHash1_3, cache_hits[0].hash));
   }
 
   {
     // kFullHash1_2 has no cache hit, and no prefix hit because of the cache for
     // kPrefix1.
     std::vector<SBFullHash> full_hashes(1, kFullHash1_2);
     std::vector<SBPrefix> prefix_hits;
     std::vector<SBFullHashResult> cache_hits;
-    EXPECT_FALSE(database_->ContainsBrowseUrlHashesForTesting(
+    EXPECT_FALSE(database_->ContainsBrowseHashes(
         full_hashes, &prefix_hits, &cache_hits));
 
     // Other prefix hits possible when kFullHash1_2 hits nothing.
     full_hashes.push_back(kFullHash2_1);
     prefix_hits.clear();
     cache_hits.clear();
-    EXPECT_TRUE(database_->ContainsBrowseUrlHashesForTesting(
+    EXPECT_TRUE(database_->ContainsBrowseHashes(
         full_hashes, &prefix_hits, &cache_hits));
     ASSERT_EQ(1U, prefix_hits.size());
     EXPECT_EQ(kPrefix2, prefix_hits[0]);
     EXPECT_TRUE(cache_hits.empty());
   }
 }
 
 TEST_F(SafeBrowsingDatabaseTest, BrowseFullHashMatching) {
   const SBPrefix kPrefix1 = 1001U;
   const SBFullHash kFullHash1_1 =
@@ skipping 11 matching lines @@
   std::vector<SBListChunkRanges> lists;
   ASSERT_TRUE(database_->UpdateStarted(&lists));
   database_->InsertChunks(kMalwareList, chunks);
   database_->UpdateFinished(true);
 
   {
     // Check a full hash which isn't present.
     std::vector<SBFullHash> full_hashes(1, kFullHash1_3);
     std::vector<SBPrefix> prefix_hits;
     std::vector<SBFullHashResult> cache_hits;
-    EXPECT_FALSE(database_->ContainsBrowseUrlHashesForTesting(
+    EXPECT_FALSE(database_->ContainsBrowseHashes(
         full_hashes, &prefix_hits, &cache_hits));
 
     // Also one which is present, should have a prefix hit.
     full_hashes.push_back(kFullHash1_1);
     prefix_hits.clear();
     cache_hits.clear();
-    EXPECT_TRUE(database_->ContainsBrowseUrlHashesForTesting(
+    EXPECT_TRUE(database_->ContainsBrowseHashes(
         full_hashes, &prefix_hits, &cache_hits));
     ASSERT_EQ(1U, prefix_hits.size());
     EXPECT_EQ(kPrefix1, prefix_hits[0]);
     EXPECT_TRUE(cache_hits.empty());
 
     // Two full hash matches with the same prefix should return one prefix hit.
     full_hashes.push_back(kFullHash1_2);
     prefix_hits.clear();
     cache_hits.clear();
-    EXPECT_TRUE(database_->ContainsBrowseUrlHashesForTesting(
+    EXPECT_TRUE(database_->ContainsBrowseHashes(
         full_hashes, &prefix_hits, &cache_hits));
     ASSERT_EQ(1U, prefix_hits.size());
     EXPECT_EQ(kPrefix1, prefix_hits[0]);
     EXPECT_TRUE(cache_hits.empty());
   }
 
   {
     // Cache a gethash result for kFullHash1_2.
     SBFullHashResult full_hash_result;
     full_hash_result.list_id = MALWARE;
     full_hash_result.hash = kFullHash1_2;
 
     std::vector<SBPrefix> prefixes(1, kPrefix1);
     std::vector<SBFullHashResult> cache_results(1, full_hash_result);
 
     database_->CacheHashResults(prefixes, cache_results, kCacheLifetime);
   }
 
   {
     // kFullHash1_3 should still return false, because the cached
     // result for kPrefix1 doesn't contain kFullHash1_3.
     std::vector<SBFullHash> full_hashes(1, kFullHash1_3);
     std::vector<SBPrefix> prefix_hits;
     std::vector<SBFullHashResult> cache_hits;
-    EXPECT_FALSE(database_->ContainsBrowseUrlHashesForTesting(
+    EXPECT_FALSE(database_->ContainsBrowseHashes(
         full_hashes, &prefix_hits, &cache_hits));
 
     // kFullHash1_1 is also not in the cached result, which takes
     // priority over the database.
     prefix_hits.clear();
     full_hashes.push_back(kFullHash1_1);
     cache_hits.clear();
-    EXPECT_FALSE(database_->ContainsBrowseUrlHashesForTesting(
+    EXPECT_FALSE(database_->ContainsBrowseHashes(
         full_hashes, &prefix_hits, &cache_hits));
 
     // kFullHash1_2 is in the cached result.
     full_hashes.push_back(kFullHash1_2);
     prefix_hits.clear();
     cache_hits.clear();
-    EXPECT_TRUE(database_->ContainsBrowseUrlHashesForTesting(
+    EXPECT_TRUE(database_->ContainsBrowseHashes(
         full_hashes, &prefix_hits, &cache_hits));
     EXPECT_TRUE(prefix_hits.empty());
     ASSERT_EQ(1U, cache_hits.size());
     EXPECT_TRUE(SBFullHashEqual(
         kFullHash1_2, cache_hits[0].hash));
   }
 
   // Remove kFullHash1_1 from the database.
   chunks.clear();
   chunks.push_back(SubChunkFullHash(11, kFullHash1_1, 1));
 
   ASSERT_TRUE(database_->UpdateStarted(&lists));
   database_->InsertChunks(kMalwareList, chunks);
   database_->UpdateFinished(true);
 
   // Cache should be cleared after updating.
   EXPECT_TRUE(
       database_->GetUnsynchronizedPrefixGetHashCacheForTesting()->empty());
 
   {
     // Now the database doesn't contain kFullHash1_1.
     std::vector<SBFullHash> full_hashes(1, kFullHash1_1);
     std::vector<SBPrefix> prefix_hits;
     std::vector<SBFullHashResult> cache_hits;
-    EXPECT_FALSE(database_->ContainsBrowseUrlHashesForTesting(
+    EXPECT_FALSE(database_->ContainsBrowseHashes(
         full_hashes, &prefix_hits, &cache_hits));
 
     // Nor kFullHash1_3.
     full_hashes.push_back(kFullHash1_3);
     prefix_hits.clear();
     cache_hits.clear();
-    EXPECT_FALSE(database_->ContainsBrowseUrlHashesForTesting(
+    EXPECT_FALSE(database_->ContainsBrowseHashes(
         full_hashes, &prefix_hits, &cache_hits));
 
     // Still has kFullHash1_2.
     full_hashes.push_back(kFullHash1_2);
     prefix_hits.clear();
     cache_hits.clear();
-    EXPECT_TRUE(database_->ContainsBrowseUrlHashesForTesting(
+    EXPECT_TRUE(database_->ContainsBrowseHashes(
         full_hashes, &prefix_hits, &cache_hits));
     ASSERT_EQ(1U, prefix_hits.size());
     EXPECT_EQ(kPrefix1, prefix_hits[0]);
     EXPECT_TRUE(cache_hits.empty());
   }
 
   // Remove kFullHash1_2 from the database.
   chunks.clear();
   chunks.push_back(SubChunkFullHash(12, kFullHash1_2, 2));
 
   ASSERT_TRUE(database_->UpdateStarted(&lists));
   database_->InsertChunks(kMalwareList, chunks);
   database_->UpdateFinished(true);
 
   // Cache should be cleared after updating.
   EXPECT_TRUE(
       database_->GetUnsynchronizedPrefixGetHashCacheForTesting()->empty());
 
   {
     // None are present.
     std::vector<SBFullHash> full_hashes;
     std::vector<SBPrefix> prefix_hits;
     std::vector<SBFullHashResult> cache_hits;
     full_hashes.push_back(kFullHash1_1);
     full_hashes.push_back(kFullHash1_2);
     full_hashes.push_back(kFullHash1_3);
-    EXPECT_FALSE(database_->ContainsBrowseUrlHashesForTesting(
+    EXPECT_FALSE(database_->ContainsBrowseHashes(
         full_hashes, &prefix_hits, &cache_hits));
   }
 }
 
 TEST_F(SafeBrowsingDatabaseTest, BrowseFullHashAndPrefixMatching) {
   const SBPrefix kPrefix1 = 1001U;
   const SBFullHash kFullHash1_1 =
       SBFullHashForPrefixAndSuffix(kPrefix1, "\x01");
   const SBFullHash kFullHash1_2 =
       SBFullHashForPrefixAndSuffix(kPrefix1, "\x02");
 
   std::vector<scoped_ptr<SBChunkData>> chunks;
   chunks.push_back(AddChunkFullHash(1, kFullHash1_1));
 
   std::vector<SBListChunkRanges> lists;
   ASSERT_TRUE(database_->UpdateStarted(&lists));
   database_->InsertChunks(kMalwareList, chunks);
   database_->UpdateFinished(true);
 
   {
     // kFullHash1_2 does not match kFullHash1_1.
     std::vector<SBFullHash> full_hashes(1, kFullHash1_2);
     std::vector<SBPrefix> prefix_hits;
     std::vector<SBFullHashResult> cache_hits;
-    EXPECT_FALSE(database_->ContainsBrowseUrlHashesForTesting(
+    EXPECT_FALSE(database_->ContainsBrowseHashes(
         full_hashes, &prefix_hits, &cache_hits));
   }
 
   // Add a prefix match.
   chunks.clear();
   chunks.push_back(AddChunkPrefix(2, kPrefix1));
 
   ASSERT_TRUE(database_->UpdateStarted(&lists));
   database_->InsertChunks(kMalwareList, chunks);
   database_->UpdateFinished(true);
 
   {
     // kFullHash1_2 does match kPrefix1.
     std::vector<SBFullHash> full_hashes(1, kFullHash1_2);
     std::vector<SBPrefix> prefix_hits;
     std::vector<SBFullHashResult> cache_hits;
-    EXPECT_TRUE(database_->ContainsBrowseUrlHashesForTesting(
+    EXPECT_TRUE(database_->ContainsBrowseHashes(
         full_hashes, &prefix_hits, &cache_hits));
     ASSERT_EQ(1U, prefix_hits.size());
     EXPECT_EQ(kPrefix1, prefix_hits[0]);
     EXPECT_TRUE(cache_hits.empty());
   }
 
   // Remove the full hash.
   chunks.clear();
   chunks.push_back(SubChunkFullHash(11, kFullHash1_1, 1));
 
   ASSERT_TRUE(database_->UpdateStarted(&lists));
   database_->InsertChunks(kMalwareList, chunks);
   database_->UpdateFinished(true);
 
   {
     // kFullHash1_2 still returns true due to the prefix hit.
     std::vector<SBFullHash> full_hashes(1, kFullHash1_2);
     std::vector<SBPrefix> prefix_hits;
     std::vector<SBFullHashResult> cache_hits;
-    EXPECT_TRUE(database_->ContainsBrowseUrlHashesForTesting(
+    EXPECT_TRUE(database_->ContainsBrowseHashes(
         full_hashes, &prefix_hits, &cache_hits));
     ASSERT_EQ(1U, prefix_hits.size());
     EXPECT_EQ(kPrefix1, prefix_hits[0]);
     EXPECT_TRUE(cache_hits.empty());
   }
 }
 
 TEST_F(SafeBrowsingDatabaseTest, MalwareIpBlacklist) {
   std::vector<SBListChunkRanges> lists;
   ASSERT_TRUE(database_->UpdateStarted(&lists));
@@ skipping 124 matching lines @@
   ASSERT_EQ(1U, prefix_hits.size());
   EXPECT_EQ(SBPrefixForString(kExampleCollision), prefix_hits[0]);
   EXPECT_TRUE(cache_hits.empty());
 
   // This prefix collides, but no full hash match.
   EXPECT_FALSE(database_->ContainsBrowseUrl(
       GURL(std::string("http://") + kExampleFine), &prefix_hits, &cache_hits));
 }
 
 }  // namespace safe_browsing