Make SafeBrowsingDatabase's PrefixSets only updatable by swapping a new one in.

chrome/browser/safe_browsing/prefix_set_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.
 
 #include "chrome/browser/safe_browsing/prefix_set.h"
 
 #include <algorithm>
 #include <iterator>
 #include <set>
 #include <string>
@@ skipping 203 matching lines @@
 // Test that a small sparse random input works.
 TEST_F(PrefixSetTest, Baseline) {
   PrefixSetBuilder builder(shared_prefixes_);
   CheckPrefixes(*builder.GetPrefixSetNoHashes(), shared_prefixes_);
 }
 
 // Test that the empty set doesn't appear to have anything in it.
 TEST_F(PrefixSetTest, Empty) {
   const std::vector<SBPrefix> empty;
   PrefixSetBuilder builder(empty);
-  scoped_ptr<PrefixSet> prefix_set = builder.GetPrefixSetNoHashes();
+  scoped_ptr<const PrefixSet> prefix_set = builder.GetPrefixSetNoHashes();
   for (size_t i = 0; i < shared_prefixes_.size(); ++i) {
     EXPECT_FALSE(prefix_set->PrefixExists(shared_prefixes_[i]));
   }
 }
 
 // Single-element set should work fine.
 TEST_F(PrefixSetTest, OneElement) {
   const std::vector<SBPrefix> prefixes(100, 0u);
   PrefixSetBuilder builder(prefixes);
-  scoped_ptr<PrefixSet> prefix_set = builder.GetPrefixSetNoHashes();
+  scoped_ptr<const PrefixSet> prefix_set = builder.GetPrefixSetNoHashes();
   EXPECT_FALSE(prefix_set->PrefixExists(static_cast<SBPrefix>(-1)));
   EXPECT_TRUE(prefix_set->PrefixExists(prefixes[0]));
   EXPECT_FALSE(prefix_set->PrefixExists(1u));
 
   // Check that |GetPrefixes()| returns the same set of prefixes as
   // was passed in.
   std::vector<SBPrefix> prefixes_copy;
   prefix_set->GetPrefixes(&prefixes_copy);
   EXPECT_EQ(1U, prefixes_copy.size());
   EXPECT_EQ(prefixes[0], prefixes_copy[0]);
 }
 
 // Edges of the 32-bit integer range.
 TEST_F(PrefixSetTest, IntMinMax) {
   std::vector<SBPrefix> prefixes;
 
   // Using bit patterns rather than portable constants because this
   // really is testing how the entire 32-bit integer range is handled.
   prefixes.push_back(0x00000000);
   prefixes.push_back(0x0000FFFF);
   prefixes.push_back(0x7FFF0000);
   prefixes.push_back(0x7FFFFFFF);
   prefixes.push_back(0x80000000);
   prefixes.push_back(0x8000FFFF);
   prefixes.push_back(0xFFFF0000);
   prefixes.push_back(0xFFFFFFFF);
 
   std::sort(prefixes.begin(), prefixes.end());
   PrefixSetBuilder builder(prefixes);
-  scoped_ptr<PrefixSet> prefix_set = builder.GetPrefixSetNoHashes();
+  scoped_ptr<const PrefixSet> prefix_set = builder.GetPrefixSetNoHashes();
 
   // Check that |GetPrefixes()| returns the same set of prefixes as
   // was passed in.
   std::vector<SBPrefix> prefixes_copy;
   prefix_set->GetPrefixes(&prefixes_copy);
   ASSERT_EQ(prefixes_copy.size(), prefixes.size());
   EXPECT_TRUE(std::equal(prefixes.begin(), prefixes.end(),
                          prefixes_copy.begin()));
 }
 
 // A range with only large deltas.
 TEST_F(PrefixSetTest, AllBig) {
   std::vector<SBPrefix> prefixes;
 
   const unsigned kDelta = 10 * 1000 * 1000;
   for (SBPrefix prefix = kHighBitSet;
        prefix < kHighBitClear; prefix += kDelta) {
     prefixes.push_back(prefix);
   }
 
   std::sort(prefixes.begin(), prefixes.end());
   PrefixSetBuilder builder(prefixes);
-  scoped_ptr<PrefixSet> prefix_set = builder.GetPrefixSetNoHashes();
+  scoped_ptr<const PrefixSet> prefix_set = builder.GetPrefixSetNoHashes();
 
   // Check that |GetPrefixes()| returns the same set of prefixes as
   // was passed in.
   std::vector<SBPrefix> prefixes_copy;
   prefix_set->GetPrefixes(&prefixes_copy);
   prefixes.erase(std::unique(prefixes.begin(), prefixes.end()), prefixes.end());
   EXPECT_EQ(prefixes_copy.size(), prefixes.size());
   EXPECT_TRUE(std::equal(prefixes.begin(), prefixes.end(),
                          prefixes_copy.begin()));
 }
@@ skipping 33 matching lines @@
   prefix = kHighBitClear - delta * 1000;
   prefixes.push_back(prefix);
   for (int i = 0; i < 1000; ++i) {
     prefix += delta;
     prefixes.push_back(prefix);
     delta--;
   }
 
   std::sort(prefixes.begin(), prefixes.end());
   PrefixSetBuilder builder(prefixes);
-  scoped_ptr<PrefixSet> prefix_set = builder.GetPrefixSetNoHashes();
+  scoped_ptr<const PrefixSet> prefix_set = builder.GetPrefixSetNoHashes();
 
   // Check that |GetPrefixes()| returns the same set of prefixes as
   // was passed in.
   std::vector<SBPrefix> prefixes_copy;
   prefix_set->GetPrefixes(&prefixes_copy);
   prefixes.erase(std::unique(prefixes.begin(), prefixes.end()), prefixes.end());
   EXPECT_EQ(prefixes_copy.size(), prefixes.size());
   EXPECT_TRUE(std::equal(prefixes.begin(), prefixes.end(),
                          prefixes_copy.begin()));
 
@@ skipping 13 matching lines @@
 }
 
 // Test writing a prefix set to disk and reading it back in.
 TEST_F(PrefixSetTest, ReadWrite) {
   base::FilePath filename;
 
   // Write the sample prefix set out, read it back in, and check all
   // the prefixes.  Leaves the path in |filename|.
   {
     ASSERT_TRUE(GetPrefixSetFile(&filename));
-    scoped_ptr<PrefixSet> prefix_set = PrefixSet::LoadFile(filename);
+    scoped_ptr<const PrefixSet> prefix_set = PrefixSet::LoadFile(filename);
     ASSERT_TRUE(prefix_set.get());
     CheckPrefixes(*prefix_set, shared_prefixes_);
   }
 
   // Test writing and reading a very sparse set containing no deltas.
   {
     std::vector<SBPrefix> prefixes;
     prefixes.push_back(kHighBitClear);
     prefixes.push_back(kHighBitSet);
 
     PrefixSetBuilder builder(prefixes);
     ASSERT_TRUE(builder.GetPrefixSetNoHashes()->WriteFile(filename));
 
-    scoped_ptr<PrefixSet> prefix_set = PrefixSet::LoadFile(filename);
+    scoped_ptr<const PrefixSet> prefix_set = PrefixSet::LoadFile(filename);
     ASSERT_TRUE(prefix_set.get());
     CheckPrefixes(*prefix_set, prefixes);
   }
 
   // Test writing and reading an empty set.
   {
     std::vector<SBPrefix> prefixes;
     PrefixSetBuilder builder(prefixes);
     ASSERT_TRUE(builder.GetPrefixSetNoHashes()->WriteFile(filename));
 
-    scoped_ptr<PrefixSet> prefix_set = PrefixSet::LoadFile(filename);
+    scoped_ptr<const PrefixSet> prefix_set = PrefixSet::LoadFile(filename);
     ASSERT_TRUE(prefix_set.get());
     CheckPrefixes(*prefix_set, prefixes);
   }
 
   // Test that full hashes are persisted.
   {
     std::vector<SBFullHash> hashes;
     hashes.push_back(SBFullHashForString("one"));
     hashes.push_back(SBFullHashForString("two"));
     hashes.push_back(SBFullHashForString("three"));
 
     std::vector<SBPrefix> prefixes(shared_prefixes_);
 
     // Remove any collisions from the prefixes.
     for (size_t i = 0; i < hashes.size(); ++i) {
       std::vector<SBPrefix>::iterator iter =
           std::lower_bound(prefixes.begin(), prefixes.end(), hashes[i].prefix);
       if (iter != prefixes.end() && *iter == hashes[i].prefix)
         prefixes.erase(iter);
     }
 
     PrefixSetBuilder builder(prefixes);
     ASSERT_TRUE(builder.GetPrefixSet(hashes)->WriteFile(filename));
 
-    scoped_ptr<PrefixSet> prefix_set = PrefixSet::LoadFile(filename);
+    scoped_ptr<const PrefixSet> prefix_set = PrefixSet::LoadFile(filename);
     ASSERT_TRUE(prefix_set.get());
     CheckPrefixes(*prefix_set, prefixes);
 
     EXPECT_TRUE(prefix_set->Exists(hashes[0]));
     EXPECT_TRUE(prefix_set->Exists(hashes[1]));
     EXPECT_TRUE(prefix_set->Exists(hashes[2]));
     EXPECT_FALSE(prefix_set->PrefixExists(hashes[0].prefix));
     EXPECT_FALSE(prefix_set->PrefixExists(hashes[1].prefix));
     EXPECT_FALSE(prefix_set->PrefixExists(hashes[2].prefix));
   }
 }
 
 // Check that |CleanChecksum()| makes an acceptable checksum.
 TEST_F(PrefixSetTest, CorruptionHelpers) {
   base::FilePath filename;
   ASSERT_TRUE(GetPrefixSetFile(&filename));
 
   // This will modify data in |index_|, which will fail the digest check.
   base::ScopedFILE file(base::OpenFile(filename, "r+b"));
   IncrementIntAt(file.get(), kPayloadOffset, 1);
   file.reset();
-  scoped_ptr<PrefixSet> prefix_set = PrefixSet::LoadFile(filename);
+  scoped_ptr<const PrefixSet> prefix_set = PrefixSet::LoadFile(filename);
   ASSERT_FALSE(prefix_set.get());
 
   // Fix up the checksum and it will read successfully (though the
   // data will be wrong).
   file.reset(base::OpenFile(filename, "r+b"));
   CleanChecksum(file.get());
   file.reset();
   prefix_set = PrefixSet::LoadFile(filename);
   ASSERT_TRUE(prefix_set.get());
 }
 
 // Bad magic is caught by the sanity check.
 TEST_F(PrefixSetTest, CorruptionMagic) {
   base::FilePath filename;
   ASSERT_TRUE(GetPrefixSetFile(&filename));
 
   ASSERT_NO_FATAL_FAILURE(
       ModifyAndCleanChecksum(filename, kMagicOffset, 1));
-  scoped_ptr<PrefixSet> prefix_set = PrefixSet::LoadFile(filename);
+  scoped_ptr<const PrefixSet> prefix_set = PrefixSet::LoadFile(filename);
   ASSERT_FALSE(prefix_set.get());
 }
 
 // Bad version is caught by the sanity check.
 TEST_F(PrefixSetTest, CorruptionVersion) {
   base::FilePath filename;
   ASSERT_TRUE(GetPrefixSetFile(&filename));
 
   ASSERT_NO_FATAL_FAILURE(
       ModifyAndCleanChecksum(filename, kVersionOffset, 10));
-  scoped_ptr<PrefixSet> prefix_set = PrefixSet::LoadFile(filename);
+  scoped_ptr<const PrefixSet> prefix_set = PrefixSet::LoadFile(filename);
   ASSERT_FALSE(prefix_set.get());
 }
 
 // Bad |index_| size is caught by the sanity check.
 TEST_F(PrefixSetTest, CorruptionIndexSize) {
   base::FilePath filename;
   ASSERT_TRUE(GetPrefixSetFile(&filename));
 
   ASSERT_NO_FATAL_FAILURE(
       ModifyAndCleanChecksum(filename, kIndexSizeOffset, 1));
-  scoped_ptr<PrefixSet> prefix_set = PrefixSet::LoadFile(filename);
+  scoped_ptr<const PrefixSet> prefix_set = PrefixSet::LoadFile(filename);
   ASSERT_FALSE(prefix_set.get());
 }
 
 // Bad |deltas_| size is caught by the sanity check.
 TEST_F(PrefixSetTest, CorruptionDeltasSize) {
   base::FilePath filename;
   ASSERT_TRUE(GetPrefixSetFile(&filename));
 
   ASSERT_NO_FATAL_FAILURE(
       ModifyAndCleanChecksum(filename, kDeltasSizeOffset, 1));
-  scoped_ptr<PrefixSet> prefix_set = PrefixSet::LoadFile(filename);
+  scoped_ptr<const PrefixSet> prefix_set = PrefixSet::LoadFile(filename);
   ASSERT_FALSE(prefix_set.get());
 }
 
 // Bad |full_hashes_| size is caught by the sanity check.
 TEST_F(PrefixSetTest, CorruptionFullHashesSize) {
   base::FilePath filename;
   ASSERT_TRUE(GetPrefixSetFile(&filename));
 
   ASSERT_NO_FATAL_FAILURE(
       ModifyAndCleanChecksum(filename, kFullHashesSizeOffset, 1));
-  scoped_ptr<PrefixSet> prefix_set = PrefixSet::LoadFile(filename);
+  scoped_ptr<const PrefixSet> prefix_set = PrefixSet::LoadFile(filename);
   ASSERT_FALSE(prefix_set.get());
 }
 
 // Test that the digest catches corruption in the middle of the file
 // (in the payload between the header and the digest).
 TEST_F(PrefixSetTest, CorruptionPayload) {
   base::FilePath filename;
   ASSERT_TRUE(GetPrefixSetFile(&filename));
 
   base::ScopedFILE file(base::OpenFile(filename, "r+b"));
   ASSERT_NO_FATAL_FAILURE(IncrementIntAt(file.get(), 666, 1));
   file.reset();
-  scoped_ptr<PrefixSet> prefix_set = PrefixSet::LoadFile(filename);
+  scoped_ptr<const PrefixSet> prefix_set = PrefixSet::LoadFile(filename);
   ASSERT_FALSE(prefix_set.get());
 }
 
 // Test corruption in the digest itself.
 TEST_F(PrefixSetTest, CorruptionDigest) {
   base::FilePath filename;
   ASSERT_TRUE(GetPrefixSetFile(&filename));
 
   int64 size_64;
   ASSERT_TRUE(base::GetFileSize(filename, &size_64));
   base::ScopedFILE file(base::OpenFile(filename, "r+b"));
   long digest_offset = static_cast<long>(size_64 - sizeof(base::MD5Digest));
   ASSERT_NO_FATAL_FAILURE(IncrementIntAt(file.get(), digest_offset, 1));
   file.reset();
-  scoped_ptr<PrefixSet> prefix_set = PrefixSet::LoadFile(filename);
+  scoped_ptr<const PrefixSet> prefix_set = PrefixSet::LoadFile(filename);
   ASSERT_FALSE(prefix_set.get());
 }
 
 // Test excess data after the digest (fails the size test).
 TEST_F(PrefixSetTest, CorruptionExcess) {
   base::FilePath filename;
   ASSERT_TRUE(GetPrefixSetFile(&filename));
 
   // Add some junk to the trunk.
   base::ScopedFILE file(base::OpenFile(filename, "ab"));
   const char buf[] = "im in ur base, killing ur d00dz.";
   ASSERT_EQ(strlen(buf), fwrite(buf, 1, strlen(buf), file.get()));
   file.reset();
-  scoped_ptr<PrefixSet> prefix_set = PrefixSet::LoadFile(filename);
+  scoped_ptr<const PrefixSet> prefix_set = PrefixSet::LoadFile(filename);
   ASSERT_FALSE(prefix_set.get());
 }
 
 // Test that files which had 64-bit size_t are discarded.
 TEST_F(PrefixSetTest, SizeTRecovery) {
   base::FilePath filename;
   ASSERT_TRUE(GetPrefixSetFile(&filename));
 
   // Open the file for rewrite.
   base::ScopedFILE file(base::OpenFile(filename, "r+b"));
@@ skipping 21 matching lines @@
   ASSERT_EQ(sizeof(delta), fwrite(&delta, 1, sizeof(delta), file.get()));
   ASSERT_EQ(sizeof(delta), fwrite(&delta, 1, sizeof(delta), file.get()));
 
   // Leave space for the digest at the end, and regenerate it.
   base::MD5Digest dummy = { { 0 } };
   ASSERT_EQ(sizeof(dummy), fwrite(&dummy, 1, sizeof(dummy), file.get()));
   ASSERT_TRUE(base::TruncateFile(file.get()));
   CleanChecksum(file.get());
   file.reset();  // Flush updates.
 
-  scoped_ptr<PrefixSet> prefix_set = PrefixSet::LoadFile(filename);
+  scoped_ptr<const PrefixSet> prefix_set = PrefixSet::LoadFile(filename);
   ASSERT_FALSE(prefix_set.get());
 }
 
 // Test Exists() against full hashes passed to builder.
 TEST_F(PrefixSetTest, FullHashBuild) {
   const SBFullHash kHash1 = SBFullHashForString("one");
   const SBFullHash kHash2 = SBFullHashForString("two");
   const SBFullHash kHash3 = SBFullHashForString("three");
   const SBFullHash kHash4 = SBFullHashForString("four");
   const SBFullHash kHash5 = SBFullHashForString("five");
   const SBFullHash kHash6 = SBFullHashForString("six");
 
   std::vector<SBPrefix> prefixes;
   prefixes.push_back(kHash1.prefix);
   prefixes.push_back(kHash2.prefix);
   std::sort(prefixes.begin(), prefixes.end());
 
   std::vector<SBFullHash> hashes;
   hashes.push_back(kHash4);
   hashes.push_back(kHash5);
 
   PrefixSetBuilder builder(prefixes);
-  scoped_ptr<PrefixSet> prefix_set = builder.GetPrefixSet(hashes);
+  scoped_ptr<const PrefixSet> prefix_set = builder.GetPrefixSet(hashes);
 
   EXPECT_TRUE(prefix_set->Exists(kHash1));
   EXPECT_TRUE(prefix_set->Exists(kHash2));
   EXPECT_FALSE(prefix_set->Exists(kHash3));
   EXPECT_TRUE(prefix_set->Exists(kHash4));
   EXPECT_TRUE(prefix_set->Exists(kHash5));
   EXPECT_FALSE(prefix_set->Exists(kHash6));
 
   EXPECT_TRUE(prefix_set->PrefixExists(kHash1.prefix));
   EXPECT_TRUE(prefix_set->PrefixExists(kHash2.prefix));
@@ skipping 37 matching lines @@
   ASSERT_EQ(sizeof(delta), fwrite(&delta, 1, sizeof(delta), file.get()));
   ASSERT_EQ(sizeof(delta), fwrite(&delta, 1, sizeof(delta), file.get()));
 
   // Leave space for the digest at the end, and regenerate it.
   base::MD5Digest dummy = { { 0 } };
   ASSERT_EQ(sizeof(dummy), fwrite(&dummy, 1, sizeof(dummy), file.get()));
   ASSERT_TRUE(base::TruncateFile(file.get()));
   CleanChecksum(file.get());
   file.reset();  // Flush updates.
 
-  scoped_ptr<safe_browsing::PrefixSet>
-      prefix_set(safe_browsing::PrefixSet::LoadFile(filename));
+  scoped_ptr<const PrefixSet> prefix_set = PrefixSet::LoadFile(filename);
   ASSERT_FALSE(prefix_set.get());
 }
 
 // Test that a golden v2 file is discarded on read.  All platforms generating v2
 // files are little-endian, so there is no point to testing this transition
 // if/when a big-endian port is added.
 #if defined(ARCH_CPU_LITTLE_ENDIAN)
 TEST_F(PrefixSetTest, Version2) {
   std::vector<SBPrefix> ref_prefixes;
   ASSERT_TRUE(ReadReferencePrefixes(&ref_prefixes));
 
   const char kBasename[] = "PrefixSetVersion2";
   base::FilePath golden_path;
   ASSERT_TRUE(PathService::Get(chrome::DIR_TEST_DATA, &golden_path));
   golden_path = golden_path.AppendASCII("SafeBrowsing");
   golden_path = golden_path.AppendASCII(kBasename);
 
-  scoped_ptr<PrefixSet> prefix_set = PrefixSet::LoadFile(golden_path);
+  scoped_ptr<const PrefixSet> prefix_set(PrefixSet::LoadFile(golden_path));
   ASSERT_FALSE(prefix_set.get());
 }
 #endif
 
 // Test that a golden v3 file can be read by the current code.  All platforms
 // generating v3 files are little-endian, so there is no point to testing this
 // transition if/when a big-endian port is added.
 #if defined(ARCH_CPU_LITTLE_ENDIAN)
 TEST_F(PrefixSetTest, Version3) {
   std::vector<SBPrefix> ref_prefixes;
   ASSERT_TRUE(ReadReferencePrefixes(&ref_prefixes));
 
   const char kBasename[] = "PrefixSetVersion3";
   base::FilePath golden_path;
   ASSERT_TRUE(PathService::Get(chrome::DIR_TEST_DATA, &golden_path));
   golden_path = golden_path.AppendASCII("SafeBrowsing");
   golden_path = golden_path.AppendASCII(kBasename);
 
-  scoped_ptr<PrefixSet> prefix_set = PrefixSet::LoadFile(golden_path);
+  scoped_ptr<const PrefixSet> prefix_set(PrefixSet::LoadFile(golden_path));
   ASSERT_TRUE(prefix_set.get());
   CheckPrefixes(*prefix_set, ref_prefixes);
 
   const SBFullHash kHash1 = SBFullHashForString("www.evil.com/malware.html");
   const SBFullHash kHash2 = SBFullHashForString("www.evil.com/phishing.html");
 
   EXPECT_TRUE(prefix_set->Exists(kHash1));
   EXPECT_TRUE(prefix_set->Exists(kHash2));
   EXPECT_FALSE(prefix_set->PrefixExists(kHash1.prefix));
   EXPECT_FALSE(prefix_set->PrefixExists(kHash2.prefix));
 }
 #endif
 
 }  // namespace safe_browsing