Add the goog-unwanted-shavar list to a new SafeBrowsing PrefixSet.

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/files/file_util.h"
 #include "base/files/scoped_temp_dir.h"
@@ skipping 63 matching lines @@
   raw_data->set_hashes(data, data_size);
   raw_data->clear_add_numbers();
   for (size_t i = 0; i < add_chunk_numbers.size(); ++i) {
     raw_data->add_add_numbers(add_chunk_numbers[i]);
   }
 
   return new SBChunkData(raw_data.release());
 }
 
 // Create add chunk with a single prefix.
-SBChunkData* AddChunkPrefix(int chunk_number,  SBPrefix prefix) {
+SBChunkData* AddChunkPrefix(int chunk_number, SBPrefix prefix) {
   return BuildChunk(chunk_number, safe_browsing::ChunkData::ADD,
                     safe_browsing::ChunkData::PREFIX_4B,
                     &prefix, sizeof(prefix),
                     std::vector<int>());
 }
 
 // Create add chunk with a single prefix generated from |value|.
 SBChunkData* AddChunkPrefixValue(int chunk_number,
                                  const std::string& value) {
   return AddChunkPrefix(chunk_number, SBPrefixForString(value));
@@ skipping 157 matching lines @@
 
 }  // namespace
 
 class SafeBrowsingDatabaseTest : public PlatformTest {
  public:
   void SetUp() override {
     PlatformTest::SetUp();
 
     // Setup a database in a temporary directory.
     ASSERT_TRUE(temp_dir_.CreateUniqueTempDir());
-    database_.reset(new SafeBrowsingDatabaseNew);
     database_filename_ =
         temp_dir_.path().AppendASCII("SafeBrowsingTestDatabase");
-    database_->Init(database_filename_);
+
+    ResetandReloadFullDatabase();
   }
 
   void TearDown() override {
     database_.reset();
 
     PlatformTest::TearDown();
   }
 
+  // Reloads the |database_| in a new SafeBrowsingDatabaseNew object with all
+  // stores enabled.
+  void ResetandReloadFullDatabase() {
+    SafeBrowsingStoreFile* browse_store = new SafeBrowsingStoreFile();
+    SafeBrowsingStoreFile* download_store = new SafeBrowsingStoreFile();
+    SafeBrowsingStoreFile* csd_whitelist_store = new SafeBrowsingStoreFile();
+    SafeBrowsingStoreFile* download_whitelist_store =
+        new SafeBrowsingStoreFile();
+    SafeBrowsingStoreFile* extension_blacklist_store =
+        new SafeBrowsingStoreFile();
+    SafeBrowsingStoreFile* side_effect_free_whitelist_store =
+        new SafeBrowsingStoreFile();
+    SafeBrowsingStoreFile* ip_blacklist_store = new SafeBrowsingStoreFile();
+    SafeBrowsingStoreFile* unwanted_software_store =
+        new SafeBrowsingStoreFile();
+    database_.reset(
+        new SafeBrowsingDatabaseNew(browse_store,
+                                    download_store,
+                                    csd_whitelist_store,
+                                    download_whitelist_store,
+                                    extension_blacklist_store,
+                                    side_effect_free_whitelist_store,
+                                    ip_blacklist_store,
+                                    unwanted_software_store));
+    database_->Init(database_filename_);
+  }
+
   void GetListsInfo(std::vector<SBListChunkRanges>* lists) {
     lists->clear();
     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) {
@@ skipping 69 matching lines @@
   chunks.push_back(
       SubChunkPrefixValue(200, "www.phishy.com/notevil1.html", 1999));
   chunks.push_back(
       SubChunkPrefixValue(201, "www.phishy2.com/notevil1.html", 1999));
 
   ASSERT_TRUE(database_->UpdateStarted(&lists));
   database_->InsertChunks(safe_browsing_util::kPhishingList, chunks.get());
   database_->UpdateFinished(true);
 
   GetListsInfo(&lists);
-  ASSERT_EQ(2U, lists.size());
+  ASSERT_LE(2U, lists.size());
   EXPECT_EQ(safe_browsing_util::kMalwareList, lists[0].name);
   EXPECT_EQ("1-3", lists[0].adds);
   EXPECT_EQ("7", lists[0].subs);
   EXPECT_EQ(safe_browsing_util::kPhishingList, lists[1].name);
   EXPECT_EQ("47", lists[1].adds);
   EXPECT_EQ("200-201", lists[1].subs);
 }
 
 TEST_F(SafeBrowsingDatabaseTest, ListNameForBrowseAndDownload) {
-  database_.reset();
-  base::MessageLoop loop;
-  SafeBrowsingStoreFile* browse_store = new SafeBrowsingStoreFile();
-  SafeBrowsingStoreFile* download_store = new SafeBrowsingStoreFile();
-  SafeBrowsingStoreFile* csd_whitelist_store = new SafeBrowsingStoreFile();
-  SafeBrowsingStoreFile* download_whitelist_store = new SafeBrowsingStoreFile();
-  SafeBrowsingStoreFile* extension_blacklist_store =
-      new SafeBrowsingStoreFile();
-  SafeBrowsingStoreFile* ip_blacklist_store = new SafeBrowsingStoreFile();
-  database_.reset(new SafeBrowsingDatabaseNew(browse_store,
-                                              download_store,
-                                              csd_whitelist_store,
-                                              download_whitelist_store,
-                                              extension_blacklist_store,
-                                              NULL,
-                                              ip_blacklist_store));
-  database_->Init(database_filename_);
-
   ScopedVector<SBChunkData> chunks;
 
   std::vector<SBListChunkRanges> lists;
   ASSERT_TRUE(database_->UpdateStarted(&lists));
 
   // Insert malware, phish, binurl and bindownload add chunks.
   chunks.push_back(AddChunkPrefixValue(1, "www.evil.com/malware.html"));
   database_->InsertChunks(safe_browsing_util::kMalwareList, chunks.get());
 
   chunks.clear();
@@ skipping 16 matching lines @@
   chunks.push_back(AddChunkFullHashValue(8,
                                          "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"
                                          "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"));
   database_->InsertChunks(safe_browsing_util::kExtensionBlacklist,
                           chunks.get());
 
   chunks.clear();
   chunks.push_back(AddChunkHashedIpValue(9, "::ffff:192.168.1.0", 120));
   database_->InsertChunks(safe_browsing_util::kIPBlacklist, chunks.get());
 
+  chunks.clear();
+  chunks.push_back(AddChunkPrefixValue(10, "www.unwanted.com/software.html"));
+  database_->InsertChunks(safe_browsing_util::kUnwantedUrlList, chunks.get());
+
   database_->UpdateFinished(true);
 
   GetListsInfo(&lists);
-  ASSERT_EQ(7U, lists.size());
+  ASSERT_EQ(9U, lists.size());
   EXPECT_EQ(safe_browsing_util::kMalwareList, lists[0].name);
   EXPECT_EQ("1", lists[0].adds);
   EXPECT_TRUE(lists[0].subs.empty());
   EXPECT_EQ(safe_browsing_util::kPhishingList, lists[1].name);
   EXPECT_EQ("2", lists[1].adds);
   EXPECT_TRUE(lists[1].subs.empty());
   EXPECT_EQ(safe_browsing_util::kBinUrlList, lists[2].name);
   EXPECT_EQ("3", lists[2].adds);
   EXPECT_TRUE(lists[2].subs.empty());
   EXPECT_EQ(safe_browsing_util::kCsdWhiteList, lists[3].name);
   EXPECT_EQ("5", lists[3].adds);
   EXPECT_TRUE(lists[3].subs.empty());
   EXPECT_EQ(safe_browsing_util::kDownloadWhiteList, lists[4].name);
   EXPECT_EQ("6", lists[4].adds);
   EXPECT_TRUE(lists[4].subs.empty());
   EXPECT_EQ(safe_browsing_util::kExtensionBlacklist, lists[5].name);
   EXPECT_EQ("8", lists[5].adds);
   EXPECT_TRUE(lists[5].subs.empty());
-  EXPECT_EQ(safe_browsing_util::kIPBlacklist, lists[6].name);
-  EXPECT_EQ("9", lists[6].adds);
-  EXPECT_TRUE(lists[6].subs.empty());
+  EXPECT_EQ(safe_browsing_util::kIPBlacklist, lists[7].name);
+  EXPECT_EQ("9", lists[7].adds);
+  EXPECT_TRUE(lists[7].subs.empty());
+  EXPECT_EQ(safe_browsing_util::kUnwantedUrlList, lists[8].name);
+  EXPECT_EQ("10", lists[8].adds);
+  EXPECT_TRUE(lists[8].subs.empty());
 
   database_.reset();
 }
 
-// Checks database reading and writing for browse.
-TEST_F(SafeBrowsingDatabaseTest, BrowseDatabase) {
-  std::vector<SBListChunkRanges> lists;
-  ScopedVector<SBChunkData> chunks;
-
-  chunks.push_back(AddChunkPrefix2Value(1,
-                                        "www.evil.com/phishing.html",
-                                        "www.evil.com/malware.html"));
-  chunks.push_back(AddChunkPrefix4Value(2,
-                                        "www.evil.com/notevil1.html",
-                                        "www.evil.com/notevil2.html",
-                                        "www.good.com/good1.html",
-                                        "www.good.com/good2.html"));
-  chunks.push_back(AddChunkPrefixValue(3, "192.168.0.1/malware.html"));
-  chunks.push_back(AddChunkFullHashValue(7, "www.evil.com/evil.html"));
-
-  ASSERT_TRUE(database_->UpdateStarted(&lists));
-  database_->InsertChunks(safe_browsing_util::kMalwareList, chunks.get());
-  database_->UpdateFinished(true);
-
-  // Make sure they were added correctly.
-  GetListsInfo(&lists);
-  ASSERT_LE(1U, lists.size());
-  EXPECT_EQ(safe_browsing_util::kMalwareList, lists[0].name);
-  EXPECT_EQ("1-3,7", lists[0].adds);
-  EXPECT_TRUE(lists[0].subs.empty());
-
-  std::vector<SBPrefix> prefix_hits;
-  std::vector<SBFullHashResult> cache_hits;
-  EXPECT_TRUE(database_->ContainsBrowseUrl(
-      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_->ContainsBrowseUrl(
-      GURL("http://www.evil.com/malware.html"), &prefix_hits, &cache_hits));
-
-  EXPECT_TRUE(database_->ContainsBrowseUrl(
-      GURL("http://www.evil.com/notevil1.html"), &prefix_hits, &cache_hits));
-
-  EXPECT_TRUE(database_->ContainsBrowseUrl(
-      GURL("http://www.evil.com/notevil2.html"), &prefix_hits, &cache_hits));
-
-  EXPECT_TRUE(database_->ContainsBrowseUrl(
-      GURL("http://www.good.com/good1.html"), &prefix_hits, &cache_hits));
-
-  EXPECT_TRUE(database_->ContainsBrowseUrl(
-      GURL("http://www.good.com/good2.html"), &prefix_hits, &cache_hits));
-
-  EXPECT_TRUE(database_->ContainsBrowseUrl(
-      GURL("http://192.168.0.1/malware.html"), &prefix_hits, &cache_hits));
-
-  EXPECT_FALSE(database_->ContainsBrowseUrl(
-      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"), &prefix_hits, &cache_hits));
-
-  EXPECT_TRUE(database_->ContainsBrowseUrl(
-      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(safe_browsing_util::kMalwareList, chunks.get());
-  database_->UpdateFinished(true);
-
-  GetListsInfo(&lists);
-  ASSERT_LE(1U, lists.size());
-  EXPECT_EQ(safe_browsing_util::kMalwareList, lists[0].name);
-  EXPECT_EQ("1-3,7", lists[0].adds);
-  EXPECT_TRUE(lists[0].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(safe_browsing_util::kMalwareList, chunks.get());
-  database_->UpdateFinished(true);
-
-  EXPECT_TRUE(database_->ContainsBrowseUrl(
-      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_->ContainsBrowseUrl(
-      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"), &prefix_hits, &cache_hits));
-
-  EXPECT_TRUE(database_->ContainsBrowseUrl(
-      GURL("http://www.good.com/good1.html"), &prefix_hits, &cache_hits));
-
-  EXPECT_TRUE(database_->ContainsBrowseUrl(
-      GURL("http://www.good.com/good2.html"), &prefix_hits, &cache_hits));
-
-  GetListsInfo(&lists);
-  ASSERT_LE(1U, lists.size());
-  EXPECT_EQ(safe_browsing_util::kMalwareList, lists[0].name);
-  EXPECT_EQ("1-3,7", lists[0].adds);
-  EXPECT_EQ("4", lists[0].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(safe_browsing_util::kMalwareList, chunks.get());
-  database_->UpdateFinished(true);
-
-  GetListsInfo(&lists);
-  ASSERT_LE(1U, lists.size());
-  EXPECT_EQ(safe_browsing_util::kMalwareList, lists[0].name);
-  EXPECT_EQ("1-3,7", lists[0].adds);
-  EXPECT_EQ("4", lists[0].subs);
-
-  // Test removing all the prefixes from an add chunk.
-  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"), &prefix_hits, &cache_hits));
-
-  EXPECT_FALSE(database_->ContainsBrowseUrl(
-      GURL("http://www.good.com/good1.html"), &prefix_hits, &cache_hits));
-
-  EXPECT_FALSE(database_->ContainsBrowseUrl(
-      GURL("http://www.good.com/good2.html"), &prefix_hits, &cache_hits));
-
-  GetListsInfo(&lists);
-  ASSERT_LE(1U, lists.size());
-  EXPECT_EQ(safe_browsing_util::kMalwareList, lists[0].name);
-  EXPECT_EQ("1,3,7", lists[0].adds);
-  EXPECT_EQ("4", lists[0].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
-  // make sure the transcation works fine.
-  chunks.clear();
-  chunks.push_back(AddChunkPrefixValue(44, "www.redherring.com/index.html"));
-  ASSERT_TRUE(database_->UpdateStarted(&lists));
-  database_->InsertChunks(safe_browsing_util::kMalwareList, chunks.get());
-
-  // 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);
-  ASSERT_LE(1U, lists.size());
-  EXPECT_EQ(safe_browsing_util::kMalwareList, lists[0].name);
-  EXPECT_EQ("1,3,7", lists[0].adds);
-  EXPECT_TRUE(lists[0].subs.empty());
-
-  // Test a sub command coming in before the add.
-  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(safe_browsing_util::kMalwareList, chunks.get());
-  database_->UpdateFinished(true);
-
-  EXPECT_FALSE(database_->ContainsBrowseUrl(
-      GURL("http://www.notevilanymore.com/index.html"),
-      &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.
-  chunks.clear();
-  chunks.push_back(AddChunkPrefix2Value(10,
-                                        "www.notevilanymore.com/index.html",
-                                        "www.notevilanymore.com/good.html"));
-  ASSERT_TRUE(database_->UpdateStarted(&lists));
-  database_->InsertChunks(safe_browsing_util::kMalwareList, chunks.get());
-  database_->UpdateFinished(true);
-
-  EXPECT_FALSE(database_->ContainsBrowseUrl(
-      GURL("http://www.notevilanymore.com/index.html"),
-      &prefix_hits,
-      &cache_hits));
-
-  EXPECT_FALSE(database_->ContainsBrowseUrl(
-      GURL("http://www.notevilanymore.com/good.html"),
-      &prefix_hits,
-      &cache_hits));
-
-  // Reset and reload the database.  The database will rely on the prefix set.
-  database_.reset(new SafeBrowsingDatabaseNew);
-  database_->Init(database_filename_);
-
-  // Check that a prefix still hits.
-  EXPECT_TRUE(database_->ContainsBrowseUrl(
-      GURL("http://www.evil.com/phishing.html"), &prefix_hits, &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_->ContainsBrowseUrl(
-      GURL("http://www.evil.com/"), &prefix_hits, &cache_hits));
-
-  // Check that the full hash is still present.
-  EXPECT_TRUE(database_->ContainsBrowseUrl(
-      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]);
+// 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);
+
+    const char* test_list_name;
+    size_t expected_list_index;
+    TestListContainsBadUrl test_list_contains_bad_url;
+  } const kTestCases[] {
+    { safe_browsing_util::kMalwareList, 0U,
+      &SafeBrowsingDatabase::ContainsBrowseUrl },
+    { safe_browsing_util::kPhishingList, 1U,
+      &SafeBrowsingDatabase::ContainsBrowseUrl },
+    { safe_browsing_util::kUnwantedUrlList, 8U,
+      &SafeBrowsingDatabase::ContainsUnwantedSoftwareUrl },
+  };
+
+  for (const auto& test_case : kTestCases) {
+    LOG(INFO) << "Testing " << test_case.test_list_name;

[mattm, 2014/11/11 01:29:11]

use SCOPED_TRACE

[gab, 2014/11/11 23:39:12]

Oh nice! Didn't know about SCOPED_TRACE, this is exactly what I want :-)!

+
+    std::vector<SBListChunkRanges> lists;
+    ScopedVector<SBChunkData> chunks;
+
+    chunks.push_back(AddChunkPrefix2Value(1,
+                                          "www.evil.com/phishing.html",
+                                          "www.evil.com/malware.html"));
+    chunks.push_back(AddChunkPrefix4Value(2,
+                                          "www.evil.com/notevil1.html",
+                                          "www.evil.com/notevil2.html",
+                                          "www.good.com/good1.html",
+                                          "www.good.com/good2.html"));
+    chunks.push_back(AddChunkPrefixValue(3, "192.168.0.1/malware.html"));
+    chunks.push_back(AddChunkFullHashValue(7, "www.evil.com/evil.html"));
+
+    ASSERT_TRUE(database_->UpdateStarted(&lists));
+    database_->InsertChunks(test_case.test_list_name, chunks.get());
+    database_->UpdateFinished(true);
+
+    // Make sure they were added correctly.
+    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));
+    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));
+
+    EXPECT_TRUE((database_.get()->*test_case.test_list_contains_bad_url)(
+        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));
+
+    EXPECT_TRUE((database_.get()->*test_case.test_list_contains_bad_url)(
+        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));
+
+    EXPECT_TRUE((database_.get()->*test_case.test_list_contains_bad_url)(
+        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));
+    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));
+
+    EXPECT_TRUE((database_.get()->*test_case.test_list_contains_bad_url)(
+        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.get());
+    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.get());
+    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));
+    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));
+    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));
+
+    EXPECT_TRUE((database_.get()->*test_case.test_list_contains_bad_url)(
+        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));
+
+    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.get());
+    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));
+
+    EXPECT_FALSE((database_.get()->*test_case.test_list_contains_bad_url)(
+        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));
+
+    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
+    // make sure the transcation works fine.
+    chunks.clear();
+    chunks.push_back(AddChunkPrefixValue(44, "www.redherring.com/index.html"));
+    ASSERT_TRUE(database_->UpdateStarted(&lists));
+    database_->InsertChunks(test_case.test_list_name, chunks.get());
+
+    // Now remove the dummy entry.  If there are any problems with the
+    // transactions, asserts will fire.
+    AddDelChunk(test_case.test_list_name, 44);
+
+    // Test the subdel command.
+    SubDelChunk(test_case.test_list_name, 4);
+    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 a sub command coming in before the add.
+    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.get());
+    database_->UpdateFinished(true);
+
+    EXPECT_FALSE((database_.get()->*test_case.test_list_contains_bad_url)(
+        GURL("http://www.notevilanymore.com/index.html"),
+        &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.
+    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.get());
+    database_->UpdateFinished(true);
+
+    EXPECT_FALSE((database_.get()->*test_case.test_list_contains_bad_url)(
+        GURL("http://www.notevilanymore.com/index.html"),
+        &prefix_hits,
+        &cache_hits));
+
+    EXPECT_FALSE((database_.get()->*test_case.test_list_contains_bad_url)(
+        GURL("http://www.notevilanymore.com/good.html"),
+        &prefix_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));
+    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));
+
+    // 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));
+    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;
   ScopedVector<SBChunkData> chunks;
 
   // Populate with a couple of normal chunks.
   chunks.push_back(AddChunkPrefix2Value(1,
                                         "www.test.com/test1.html",
@@ skipping 86 matching lines @@
   chunks.push_back(AddChunkPrefix2Value(1,
                                         "www.evil.com/phishing.html",
                                         "www.evil.com/malware.html"));
 
   std::vector<SBListChunkRanges> lists;
   ASSERT_TRUE(database_->UpdateStarted(&lists));
   database_->InsertChunks(safe_browsing_util::kMalwareList, chunks.get());
   database_->UpdateFinished(true);
 
   // Cache should be cleared after updating.
-  EXPECT_TRUE(database_->browse_gethash_cache_.empty());
+  EXPECT_TRUE(database_->prefix_gethash_cache_.empty());
 
   SBFullHashResult full_hash;
   full_hash.list_id = safe_browsing_util::MALWARE;
 
   std::vector<SBFullHashResult> results;
   std::vector<SBPrefix> prefixes;
 
   // Add a fullhash result for each prefix.
   full_hash.hash = SBFullHashForString("www.evil.com/phishing.html");
   results.push_back(full_hash);
   prefixes.push_back(full_hash.hash.prefix);
 
   full_hash.hash = SBFullHashForString("www.evil.com/malware.html");
   results.push_back(full_hash);
   prefixes.push_back(full_hash.hash.prefix);
 
   database_->CacheHashResults(prefixes, results, kCacheLifetime);
 }
 
 TEST_F(SafeBrowsingDatabaseTest, HashCaching) {
   PopulateDatabaseForCacheTest();
 
   // We should have both full hashes in the cache.
-  EXPECT_EQ(2U, database_->browse_gethash_cache_.size());
+  EXPECT_EQ(2U, database_->prefix_gethash_cache_.size());
 
   // Test the cache lookup for the first prefix.
   std::vector<SBPrefix> prefix_hits;
   std::vector<SBFullHashResult> cache_hits;
   EXPECT_TRUE(database_->ContainsBrowseUrl(
       GURL("http://www.evil.com/phishing.html"), &prefix_hits, &cache_hits));
   EXPECT_TRUE(prefix_hits.empty());
   ASSERT_EQ(1U, cache_hits.size());
   EXPECT_TRUE(SBFullHashEqual(
       cache_hits[0].hash, SBFullHashForString("www.evil.com/phishing.html")));
@@ skipping 35 matching lines @@
       GURL("http://www.evil.com/phishing.html"), &prefix_hits, &cache_hits));
   prefix_hits.clear();
   cache_hits.clear();
 
   // Test that an AddDel for the original chunk removes the last cached entry.
   ASSERT_TRUE(database_->UpdateStarted(&lists));
   AddDelChunk(safe_browsing_util::kMalwareList, 1);
   database_->UpdateFinished(true);
   EXPECT_FALSE(database_->ContainsBrowseUrl(
       GURL("http://www.evil.com/malware.html"), &prefix_hits, &cache_hits));
-  EXPECT_TRUE(database_->browse_gethash_cache_.empty());
+  EXPECT_TRUE(database_->prefix_gethash_cache_.empty());
   prefix_hits.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::map<SBPrefix, SBCachedFullHashResult>* hash_cache =
-      &database_->browse_gethash_cache_;
+      &database_->prefix_gethash_cache_;
   EXPECT_EQ(2U, hash_cache->size());
 
   // Now adjust one of the entries times to be in the past.
   const SBPrefix key = SBPrefixForString("www.evil.com/malware.html");
   std::map<SBPrefix, SBCachedFullHashResult>::iterator iter =
       hash_cache->find(key);
   ASSERT_TRUE(iter != hash_cache->end());
   iter->second.expire_after = Time::Now() - TimeDelta::FromMinutes(1);
 
   EXPECT_TRUE(database_->ContainsBrowseUrl(
@@ skipping 154 matching lines @@
 // 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));
+                                              NULL, NULL, NULL));
   database_->Init(database_filename_);
 
   // This will cause an empty database to be created.
   std::vector<SBListChunkRanges> lists;
   ASSERT_TRUE(database_->UpdateStarted(&lists));
   database_->UpdateFinished(true);
 
   // Create a sub chunk to insert.
   ScopedVector<SBChunkData> chunks;
   chunks.push_back(SubChunkPrefixValue(7,
@@ skipping 34 matching lines @@
   ASSERT_TRUE(database_->UpdateStarted(&lists));
   database_->InsertChunks(safe_browsing_util::kMalwareList, chunks.get());
   database_->UpdateFinished(true);
   EXPECT_TRUE(base::PathExists(database_filename_));
 
   database_.reset();
 }
 
 // Checks database reading and writing.
 TEST_F(SafeBrowsingDatabaseTest, ContainsDownloadUrl) {
-  database_.reset();
-  base::MessageLoop loop;
-  SafeBrowsingStoreFile* browse_store = new SafeBrowsingStoreFile();
-  SafeBrowsingStoreFile* download_store = new SafeBrowsingStoreFile();
-  SafeBrowsingStoreFile* csd_whitelist_store = new SafeBrowsingStoreFile();
-  database_.reset(new SafeBrowsingDatabaseNew(browse_store,
-                                              download_store,
-                                              csd_whitelist_store,
-                                              NULL,
-                                              NULL,
-                                              NULL,
-                                              NULL));
-  database_->Init(database_filename_);
-
   const char kEvil1Url1[] = "www.evil1.com/download1/";
   const char kEvil1Url2[] = "www.evil1.com/download2.html";
 
   // Add a simple chunk with one hostkey for download url list.
   ScopedVector<SBChunkData> chunks;
   chunks.push_back(AddChunkPrefix2Value(1, kEvil1Url1, kEvil1Url2));
 
   std::vector<SBListChunkRanges> lists;
   ASSERT_TRUE(database_->UpdateStarted(&lists));
   database_->InsertChunks(safe_browsing_util::kBinUrlList, chunks.get());
@@ skipping 77 matching lines @@
 TEST_F(SafeBrowsingDatabaseTest, Whitelists) {
   database_.reset();
 
   // We expect all calls to ContainsCsdWhitelistedUrl in particular to be made
   // from the IO thread.  In general the whitelist lookups are thread-safe.
   content::TestBrowserThreadBundle thread_bundle_;
 
   // If the whitelist is disabled everything should match the whitelist.
   database_.reset(new SafeBrowsingDatabaseNew(new SafeBrowsingStoreFile(),
                                               NULL, NULL, NULL, NULL, NULL,
-                                              NULL));
+                                              NULL, NULL));
   database_->Init(database_filename_);
   EXPECT_TRUE(database_->ContainsDownloadWhitelistedUrl(
       GURL(std::string("http://www.phishing.com/"))));
   EXPECT_TRUE(database_->ContainsDownloadWhitelistedUrl(
       GURL(std::string("http://www.phishing.com/"))));
   EXPECT_TRUE(database_->ContainsDownloadWhitelistedString("asdf"));
 
-  SafeBrowsingStoreFile* browse_store = new SafeBrowsingStoreFile();
-  SafeBrowsingStoreFile* csd_whitelist_store = new SafeBrowsingStoreFile();
-  SafeBrowsingStoreFile* download_whitelist_store = new SafeBrowsingStoreFile();
-  SafeBrowsingStoreFile* extension_blacklist_store =
-      new SafeBrowsingStoreFile();
-  database_.reset(new SafeBrowsingDatabaseNew(browse_store, NULL,
-                                              csd_whitelist_store,
-                                              download_whitelist_store,
-                                              extension_blacklist_store,
-                                              NULL, NULL));
-  database_->Init(database_filename_);
+  ResetandReloadFullDatabase();
 
   const char kGood1Host[] = "www.good1.com/";
   const char kGood1Url1[] = "www.good1.com/a/b.html";
   const char kGood1Url2[] = "www.good1.com/b/";
 
   const char kGood2Url1[] = "www.good2.com/c";  // Should match '/c/bla'.
 
   // good3.com/a/b/c/d/e/f/g/ should match because it's a whitelist.
   const char kGood3Url1[] = "good3.com/";
 
@@ skipping 179 matching lines @@
   chunks.clear();
   chunks.push_back(AddChunkPrefix2Value(47,
                                         "www.evil.com/phishing1.html",
                                         "www.evil.com/phishing2.html"));
 
   ASSERT_TRUE(database_->UpdateStarted(&lists));
   database_->InsertChunks(safe_browsing_util::kPhishingList, chunks.get());
   database_->UpdateFinished(true);
 
   GetListsInfo(&lists);
-  ASSERT_EQ(2U, lists.size());
+  ASSERT_LE(2U, lists.size());
   EXPECT_EQ(safe_browsing_util::kMalwareList, lists[0].name);
   EXPECT_EQ("1", lists[0].adds);
   EXPECT_TRUE(lists[0].subs.empty());
   EXPECT_EQ(safe_browsing_util::kPhishingList, lists[1].name);
   EXPECT_EQ("47", lists[1].adds);
   EXPECT_TRUE(lists[1].subs.empty());
 
   std::vector<SBPrefix> prefix_hits;
   std::vector<SBFullHashResult> cache_hits;
 
@@ skipping 107 matching lines @@
       GURL("http://www.evil.com/malware.html"), &prefix_hits, &cache_hits));
   EXPECT_FALSE(database_->ContainsBrowseUrl(
       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_);
+  ResetandReloadFullDatabase();
   EXPECT_TRUE(database_->ContainsBrowseUrl(
       GURL("http://www.evil.com/malware.html"), &prefix_hits, &cache_hits));
   EXPECT_FALSE(database_->ContainsBrowseUrl(
       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_);
+  ResetandReloadFullDatabase();
   EXPECT_FALSE(database_->ContainsBrowseUrl(
       GURL("http://www.evil.com/malware.html"), &prefix_hits, &cache_hits));
   EXPECT_FALSE(database_->ContainsBrowseUrl(
       GURL("http://www.good.com/goodware.html"), &prefix_hits, &cache_hits));
 }
 
 TEST_F(SafeBrowsingDatabaseTest, CachedFullMiss) {
   const SBPrefix kPrefix1 = 1001U;
   const SBFullHash kFullHash1_1 =
       SBFullHashForPrefixAndSuffix(kPrefix1, "\x01");
@@ skipping 18 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_->ContainsBrowseUrlHashes(
+    EXPECT_FALSE(database_->ContainsBrowseUrlHashesForTesting(
         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_->ContainsBrowseUrlHashes(
+    EXPECT_TRUE(database_->ContainsBrowseUrlHashesForTesting(
         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(safe_browsing_util::kMalwareList, chunks.get());
   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_->ContainsBrowseUrlHashes(
+    EXPECT_TRUE(database_->ContainsBrowseUrlHashesForTesting(
         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_->ContainsBrowseUrlHashes(
+    EXPECT_TRUE(database_->ContainsBrowseUrlHashesForTesting(
         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_->ContainsBrowseUrlHashes(
+    EXPECT_TRUE(database_->ContainsBrowseUrlHashesForTesting(
         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 = safe_browsing_util::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_->ContainsBrowseUrlHashes(
+    EXPECT_TRUE(database_->ContainsBrowseUrlHashesForTesting(
         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_->ContainsBrowseUrlHashes(
+    EXPECT_TRUE(database_->ContainsBrowseUrlHashesForTesting(
         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_->ContainsBrowseUrlHashes(
+    EXPECT_TRUE(database_->ContainsBrowseUrlHashesForTesting(
         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_->ContainsBrowseUrlHashes(
+    EXPECT_TRUE(database_->ContainsBrowseUrlHashesForTesting(
         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_->ContainsBrowseUrlHashes(
+    EXPECT_FALSE(database_->ContainsBrowseUrlHashesForTesting(
         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_->ContainsBrowseUrlHashes(
+    EXPECT_TRUE(database_->ContainsBrowseUrlHashesForTesting(
         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(safe_browsing_util::kMalwareList, chunks.get());
   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_->ContainsBrowseUrlHashes(
+    EXPECT_FALSE(database_->ContainsBrowseUrlHashesForTesting(
         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_->ContainsBrowseUrlHashes(
+    EXPECT_TRUE(database_->ContainsBrowseUrlHashesForTesting(
         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_->ContainsBrowseUrlHashes(
+    EXPECT_TRUE(database_->ContainsBrowseUrlHashesForTesting(
         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 = safe_browsing_util::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_->ContainsBrowseUrlHashes(
+    EXPECT_FALSE(database_->ContainsBrowseUrlHashesForTesting(
         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_->ContainsBrowseUrlHashes(
+    EXPECT_FALSE(database_->ContainsBrowseUrlHashesForTesting(
         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_->ContainsBrowseUrlHashes(
+    EXPECT_TRUE(database_->ContainsBrowseUrlHashesForTesting(
         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(safe_browsing_util::kMalwareList, chunks.get());
   database_->UpdateFinished(true);
 
   // Cache should be cleared after updating.
-  EXPECT_TRUE(database_->browse_gethash_cache_.empty());
+  EXPECT_TRUE(database_->prefix_gethash_cache_.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_->ContainsBrowseUrlHashes(
+    EXPECT_FALSE(database_->ContainsBrowseUrlHashesForTesting(
         full_hashes, &prefix_hits, &cache_hits));
 
     // Nor kFullHash1_3.
     full_hashes.push_back(kFullHash1_3);
     prefix_hits.clear();
     cache_hits.clear();
-    EXPECT_FALSE(database_->ContainsBrowseUrlHashes(
+    EXPECT_FALSE(database_->ContainsBrowseUrlHashesForTesting(
         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_->ContainsBrowseUrlHashes(
+    EXPECT_TRUE(database_->ContainsBrowseUrlHashesForTesting(
         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(safe_browsing_util::kMalwareList, chunks.get());
   database_->UpdateFinished(true);
 
   // Cache should be cleared after updating.
-  EXPECT_TRUE(database_->browse_gethash_cache_.empty());
+  EXPECT_TRUE(database_->prefix_gethash_cache_.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_->ContainsBrowseUrlHashes(
+    EXPECT_FALSE(database_->ContainsBrowseUrlHashesForTesting(
         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");
 
   ScopedVector<SBChunkData> chunks;
   chunks.push_back(AddChunkFullHash(1, kFullHash1_1));
 
   std::vector<SBListChunkRanges> lists;
   ASSERT_TRUE(database_->UpdateStarted(&lists));
   database_->InsertChunks(safe_browsing_util::kMalwareList, chunks.get());
   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_->ContainsBrowseUrlHashes(
+    EXPECT_FALSE(database_->ContainsBrowseUrlHashesForTesting(
         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(safe_browsing_util::kMalwareList, chunks.get());
   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_->ContainsBrowseUrlHashes(
+    EXPECT_TRUE(database_->ContainsBrowseUrlHashesForTesting(
         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(safe_browsing_util::kMalwareList, chunks.get());
   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_->ContainsBrowseUrlHashes(
+    EXPECT_TRUE(database_->ContainsBrowseUrlHashesForTesting(
         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) {
-  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;
   ASSERT_TRUE(database_->UpdateStarted(&lists));
 
   ScopedVector<SBChunkData> chunks;
 
   // IPv4 prefix match for ::ffff:192.168.1.0/120.
   chunks.push_back(AddChunkHashedIpValue(1, "::ffff:192.168.1.0", 120));
 
   // IPv4 exact match for ::ffff:192.1.1.1.
   chunks.push_back(AddChunkHashedIpValue(2, "::ffff:192.1.1.1", 128));
@@ skipping 114 matching lines @@
       GURL(std::string("http://") + kExampleCollision),
       &prefix_hits, &cache_hits));
   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));
 }