Knock out injected safe-browsing prefixes.

chrome/browser/safe_browsing/safe_browsing_store_unittest.cc

 // Copyright (c) 2011 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/safe_browsing_store.h"
 
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace {
 
@@ skipping 289 matching lines @@
 
 TEST(SafeBrowsingStoreTest, Y2K38) {
   const base::Time now = base::Time::Now();
   const base::Time future = now + base::TimeDelta::FromDays(3*365);
 
   // TODO: Fix file format before 2035.
   EXPECT_GT(static_cast<int32>(future.ToTimeT()), 0)
     << " (int32)time_t is running out.";
 }
 
+// Test that prefixes which were injected from full hashes are being removed.
+// This was a mistake in earlier versions of the code.
+TEST(SafeBrowsingStoreTest, KnockoutPrefixVolunteers) {
+  const base::Time kNow = base::Time::Now();
+
+  // Construct some full hashes which share prefix with another.
+  const SBFullHash kHash1mod1 = ModifyHashAfterPrefix(kHash1, 1);
+  const SBFullHash kHash2mod1 = ModifyHashAfterPrefix(kHash2, 1);
+
+  SBAddPrefixes add_prefixes;
+  std::vector<SBAddFullHash> add_hashes;
+  SBSubPrefixes sub_prefixes;
+  std::vector<SBSubFullHash> sub_hashes;
+
+  // An add with prefix and a couple hashes from the same prefix.
+  add_prefixes.push_back(SBAddPrefix(kAddChunk1, kHash1.prefix));
+  add_hashes.push_back(SBAddFullHash(kAddChunk1, kNow, kHash1));
+  add_hashes.push_back(SBAddFullHash(kAddChunk1, kNow, kHash1mod1));
+
+  // Sub with a prefix and a couple hashes from the same prefix.
+  sub_prefixes.push_back(SBSubPrefix(kSubChunk1, kAddChunk1, kHash2.prefix));
+  sub_hashes.push_back(SBSubFullHash(kSubChunk1, kAddChunk1, kHash2));
+  sub_hashes.push_back(SBSubFullHash(kSubChunk1, kAddChunk1, kHash2mod1));
+
+  // An add with no corresponding sub.  Both items should be retained.

[mattm, 2014/05/02 01:41:09]

These comments are a little confusing since none of the adds and subs in this
test correspond.

[Scott Hess - ex-Googler, 2014/05/05 22:41:32]

Sorry, these were copied and pasted from other tests.  This test really
shouldn't touch the interactions between subs and adds, just interactions w/in
each group independently.  I'll rearrange/recomment.  I'll also adjust the chunk
numbering to be more independent.

+  add_hashes.push_back(SBAddFullHash(kAddChunk1, kNow, kHash3));
+  add_prefixes.push_back(SBAddPrefix(kAddChunk1, kHash4.prefix));
+
+  // A sub with no corresponding add.  Both items should be retained.
+  sub_hashes.push_back(SBSubFullHash(kSubChunk1, kAddChunk1, kHash5));
+  sub_prefixes.push_back(SBSubPrefix(kSubChunk1, kAddChunk1, kHash6.prefix));
+
+  const base::hash_set<int32> no_deletions;
+  ProcessHelper(&add_prefixes, &sub_prefixes, &add_hashes, &sub_hashes,
+                no_deletions, no_deletions);
+
+  ASSERT_EQ(1U, add_prefixes.size());
+  EXPECT_EQ(kAddChunk1, add_prefixes[0].chunk_id);
+  EXPECT_EQ(kHash4.prefix, add_prefixes[0].prefix);
+
+  ASSERT_EQ(3U, add_hashes.size());
+  EXPECT_EQ(kAddChunk1, add_hashes[0].chunk_id);
+  EXPECT_TRUE(SBFullHashEqual(kHash1mod1, add_hashes[0].full_hash));
+  EXPECT_EQ(kAddChunk1, add_hashes[1].chunk_id);
+  EXPECT_TRUE(SBFullHashEqual(kHash1, add_hashes[1].full_hash));
+  EXPECT_EQ(kAddChunk1, add_hashes[2].chunk_id);
+  EXPECT_TRUE(SBFullHashEqual(kHash3, add_hashes[2].full_hash));
+
+  ASSERT_EQ(1U, sub_prefixes.size());
+  EXPECT_EQ(kSubChunk1, sub_prefixes[0].chunk_id);
+  EXPECT_EQ(kAddChunk1, sub_prefixes[0].add_chunk_id);
+  EXPECT_EQ(kHash6.prefix, sub_prefixes[0].add_prefix);
+
+  ASSERT_EQ(3U, sub_hashes.size());
+  EXPECT_EQ(kSubChunk1, sub_hashes[0].chunk_id);
+  EXPECT_EQ(kAddChunk1, sub_hashes[0].add_chunk_id);
+  EXPECT_TRUE(SBFullHashEqual(kHash5, sub_hashes[0].full_hash));
+  EXPECT_EQ(kSubChunk1, sub_hashes[1].chunk_id);
+  EXPECT_EQ(kAddChunk1, sub_hashes[1].add_chunk_id);
+  EXPECT_TRUE(SBFullHashEqual(kHash2mod1, sub_hashes[1].full_hash));
+  EXPECT_EQ(kSubChunk1, sub_hashes[2].chunk_id);
+  EXPECT_EQ(kAddChunk1, sub_hashes[2].add_chunk_id);
+  EXPECT_TRUE(SBFullHashEqual(kHash2, sub_hashes[2].full_hash));
+}
+
 }  // namespace