Remove safe-browsing-store unit test helper.

This file originally existed to allow the old sqlite store to share
tests with the new file store.  The old store isn't coming back, nor is
it obvious that future store alternatives will use the same interface.

BUG=none

Review URL: https://codereview.chromium.org/197283011

git-svn-id: svn://svn.chromium.org/chrome/trunk/src@257027 0039d316-1c4b-4281-b951-d872f2087c98

3 files changed, 329 insertions, 395 deletions

diff --git a/chrome/browser/safe_browsing/safe_browsing_store_file_unittest.cc b/chrome/browser/safe_browsing/safe_browsing_store_file_unittest.cc
index 9c2a614..ac17086 100644
--- a/chrome/browser/safe_browsing/safe_browsing_store_file_unittest.cc
+++ b/chrome/browser/safe_browsing/safe_browsing_store_file_unittest.cc
@@ -7,12 +7,25 @@
 #include "base/bind.h"
 #include "base/files/scoped_temp_dir.h"
 #include "base/md5.h"
-#include "chrome/browser/safe_browsing/safe_browsing_store_unittest_helper.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "testing/platform_test.h"
 
 namespace {
 
+const int kAddChunk1 = 1;
+const int kAddChunk2 = 3;
+const int kAddChunk3 = 5;
+const int kAddChunk4 = 7;
+// Disjoint chunk numbers for subs to flush out typos.
+const int kSubChunk1 = 2;
+const int kSubChunk2 = 4;
+
+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");
+
 class SafeBrowsingStoreFileTest : public PlatformTest {
  public:
   virtual void SetUp() {
@@ -41,13 +54,323 @@ class SafeBrowsingStoreFileTest : public PlatformTest {
     corruption_detected_ = true;
   }
 
+  // Populate the store with some testing data.
+  void PopulateStore(const base::Time& now) {
+    EXPECT_TRUE(store_->BeginUpdate());
+
+    EXPECT_TRUE(store_->BeginChunk());
+    store_->SetAddChunk(kAddChunk1);
+    EXPECT_TRUE(store_->CheckAddChunk(kAddChunk1));
+    EXPECT_TRUE(store_->WriteAddPrefix(kAddChunk1, kHash1.prefix));
+    EXPECT_TRUE(store_->WriteAddPrefix(kAddChunk1, kHash2.prefix));
+    EXPECT_TRUE(store_->WriteAddHash(kAddChunk1, now, kHash2));
+
+    store_->SetSubChunk(kSubChunk1);
+    EXPECT_TRUE(store_->CheckSubChunk(kSubChunk1));
+    EXPECT_TRUE(store_->WriteSubPrefix(kSubChunk1, kAddChunk3, kHash3.prefix));
+    EXPECT_TRUE(store_->WriteSubHash(kSubChunk1, kAddChunk3, kHash3));
+    EXPECT_TRUE(store_->FinishChunk());
+
+    // Chunk numbers shouldn't leak over.
+    EXPECT_FALSE(store_->CheckAddChunk(kSubChunk1));
+    EXPECT_FALSE(store_->CheckAddChunk(kAddChunk3));
+    EXPECT_FALSE(store_->CheckSubChunk(kAddChunk1));
+
+    std::vector<SBAddFullHash> pending_adds;
+    SBAddPrefixes add_prefixes_result;
+    std::vector<SBAddFullHash> add_full_hashes_result;
+
+    EXPECT_TRUE(store_->FinishUpdate(pending_adds,
+                                     &add_prefixes_result,
+                                     &add_full_hashes_result));
+}
+
   base::ScopedTempDir temp_dir_;
   base::FilePath filename_;
   scoped_ptr<SafeBrowsingStoreFile> store_;
   bool corruption_detected_;
 };
 
-TEST_STORE(SafeBrowsingStoreFileTest, store_.get(), filename_);
+// Test that the empty store looks empty.
+TEST_F(SafeBrowsingStoreFileTest, Empty) {
+  EXPECT_TRUE(store_->BeginUpdate());
+
+  std::vector<int> chunks;
+  store_->GetAddChunks(&chunks);
+  EXPECT_TRUE(chunks.empty());
+  store_->GetSubChunks(&chunks);
+  EXPECT_TRUE(chunks.empty());
+
+  // Shouldn't see anything, but anything is a big set to test.
+  EXPECT_FALSE(store_->CheckAddChunk(0));
+  EXPECT_FALSE(store_->CheckAddChunk(1));
+  EXPECT_FALSE(store_->CheckAddChunk(-1));
+
+  EXPECT_FALSE(store_->CheckSubChunk(0));
+  EXPECT_FALSE(store_->CheckSubChunk(1));
+  EXPECT_FALSE(store_->CheckSubChunk(-1));
+
+  std::vector<SBAddFullHash> pending_adds;
+  SBAddPrefixes add_prefixes_result;
+  std::vector<SBAddFullHash> add_full_hashes_result;
+
+  EXPECT_TRUE(store_->FinishUpdate(pending_adds,
+                                   &add_prefixes_result,
+                                   &add_full_hashes_result));
+  EXPECT_TRUE(add_prefixes_result.empty());
+  EXPECT_TRUE(add_full_hashes_result.empty());
+}
+
+// Write some prefix data to the store and verify that it looks like
+// it is still there after the transaction completes.
+TEST_F(SafeBrowsingStoreFileTest, StorePrefix) {
+  const base::Time now = base::Time::Now();
+  PopulateStore(now);
+
+  EXPECT_TRUE(store_->BeginUpdate());
+
+  std::vector<int> chunks;
+  store_->GetAddChunks(&chunks);
+  ASSERT_EQ(1U, chunks.size());
+  EXPECT_EQ(kAddChunk1, chunks[0]);
+
+  store_->GetSubChunks(&chunks);
+  ASSERT_EQ(1U, chunks.size());
+  EXPECT_EQ(kSubChunk1, chunks[0]);
+
+  std::vector<SBAddFullHash> pending_adds;
+  SBAddPrefixes add_prefixes_result;
+  std::vector<SBAddFullHash> add_full_hashes_result;
+
+  EXPECT_TRUE(store_->FinishUpdate(pending_adds,
+                                   &add_prefixes_result,
+                                   &add_full_hashes_result));
+
+  ASSERT_EQ(2U, add_prefixes_result.size());
+  EXPECT_EQ(kAddChunk1, add_prefixes_result[0].chunk_id);
+  EXPECT_EQ(kHash1.prefix, add_prefixes_result[0].prefix);
+  EXPECT_EQ(kAddChunk1, add_prefixes_result[1].chunk_id);
+  EXPECT_EQ(kHash2.prefix, add_prefixes_result[1].prefix);
+
+  ASSERT_EQ(1U, add_full_hashes_result.size());
+  EXPECT_EQ(kAddChunk1, add_full_hashes_result[0].chunk_id);
+  // EXPECT_TRUE(add_full_hashes_result[0].received == now)?
+  EXPECT_EQ(now.ToTimeT(), add_full_hashes_result[0].received);
+  EXPECT_TRUE(SBFullHashEqual(kHash2, add_full_hashes_result[0].full_hash));
+
+  add_prefixes_result.clear();
+  add_full_hashes_result.clear();
+
+  EXPECT_TRUE(store_->BeginUpdate());
+
+  // Still has the chunks expected in the next update.
+  store_->GetAddChunks(&chunks);
+  ASSERT_EQ(1U, chunks.size());
+  EXPECT_EQ(kAddChunk1, chunks[0]);
+
+  store_->GetSubChunks(&chunks);
+  ASSERT_EQ(1U, chunks.size());
+  EXPECT_EQ(kSubChunk1, chunks[0]);
+
+  EXPECT_TRUE(store_->CheckAddChunk(kAddChunk1));
+  EXPECT_TRUE(store_->CheckSubChunk(kSubChunk1));
+
+  EXPECT_TRUE(store_->FinishUpdate(pending_adds,
+                                   &add_prefixes_result,
+                                   &add_full_hashes_result));
+
+  // Still has the expected contents.
+  ASSERT_EQ(2U, add_prefixes_result.size());
+  EXPECT_EQ(kAddChunk1, add_prefixes_result[0].chunk_id);
+  EXPECT_EQ(kHash1.prefix, add_prefixes_result[0].prefix);
+  EXPECT_EQ(kAddChunk1, add_prefixes_result[1].chunk_id);
+  EXPECT_EQ(kHash2.prefix, add_prefixes_result[1].prefix);
+
+  ASSERT_EQ(1U, add_full_hashes_result.size());
+  EXPECT_EQ(kAddChunk1, add_full_hashes_result[0].chunk_id);
+  EXPECT_EQ(now.ToTimeT(), add_full_hashes_result[0].received);
+  EXPECT_TRUE(SBFullHashEqual(kHash2, add_full_hashes_result[0].full_hash));
+}
+
+// Test that subs knockout adds.
+TEST_F(SafeBrowsingStoreFileTest, SubKnockout) {
+  EXPECT_TRUE(store_->BeginUpdate());
+
+  const base::Time now = base::Time::Now();
+
+  EXPECT_TRUE(store_->BeginChunk());
+  store_->SetAddChunk(kAddChunk1);
+  EXPECT_TRUE(store_->WriteAddPrefix(kAddChunk1, kHash1.prefix));
+  EXPECT_TRUE(store_->WriteAddPrefix(kAddChunk1, kHash2.prefix));
+  EXPECT_TRUE(store_->WriteAddHash(kAddChunk1, now, kHash2));
+
+  store_->SetSubChunk(kSubChunk1);
+  EXPECT_TRUE(store_->WriteSubPrefix(kSubChunk1, kAddChunk3, kHash3.prefix));
+  EXPECT_TRUE(store_->WriteSubPrefix(kSubChunk1, kAddChunk1, kHash2.prefix));
+  EXPECT_TRUE(store_->FinishChunk());
+
+  std::vector<SBAddFullHash> pending_adds;
+  SBAddPrefixes add_prefixes_result;
+  std::vector<SBAddFullHash> add_full_hashes_result;
+
+  EXPECT_TRUE(store_->FinishUpdate(pending_adds,
+                                   &add_prefixes_result,
+                                   &add_full_hashes_result));
+
+  // Knocked out the chunk expected.
+  ASSERT_EQ(1U, add_prefixes_result.size());
+  EXPECT_EQ(kAddChunk1, add_prefixes_result[0].chunk_id);
+  EXPECT_EQ(kHash1.prefix, add_prefixes_result[0].prefix);
+  EXPECT_TRUE(add_full_hashes_result.empty());
+
+  add_prefixes_result.clear();
+
+  EXPECT_TRUE(store_->BeginUpdate());
+
+  // This add should be knocked out by an existing sub.
+  EXPECT_TRUE(store_->BeginChunk());
+  store_->SetAddChunk(kAddChunk3);
+  EXPECT_TRUE(store_->WriteAddPrefix(kAddChunk3, kHash3.prefix));
+  EXPECT_TRUE(store_->FinishChunk());
+
+  EXPECT_TRUE(store_->FinishUpdate(pending_adds,
+                                   &add_prefixes_result,
+                                   &add_full_hashes_result));
+  EXPECT_EQ(1U, add_prefixes_result.size());
+  EXPECT_EQ(kAddChunk1, add_prefixes_result[0].chunk_id);
+  EXPECT_EQ(kHash1.prefix, add_prefixes_result[0].prefix);
+  EXPECT_TRUE(add_full_hashes_result.empty());
+
+  add_prefixes_result.clear();
+
+  EXPECT_TRUE(store_->BeginUpdate());
+
+  // But by here the sub should be gone, so it should stick this time.
+  EXPECT_TRUE(store_->BeginChunk());
+  store_->SetAddChunk(kAddChunk3);
+  EXPECT_TRUE(store_->WriteAddPrefix(kAddChunk3, kHash3.prefix));
+  EXPECT_TRUE(store_->FinishChunk());
+
+  EXPECT_TRUE(store_->FinishUpdate(pending_adds,
+                                   &add_prefixes_result,
+                                   &add_full_hashes_result));
+  ASSERT_EQ(2U, add_prefixes_result.size());
+  EXPECT_EQ(kAddChunk1, add_prefixes_result[0].chunk_id);
+  EXPECT_EQ(kHash1.prefix, add_prefixes_result[0].prefix);
+  EXPECT_EQ(kAddChunk3, add_prefixes_result[1].chunk_id);
+  EXPECT_EQ(kHash3.prefix, add_prefixes_result[1].prefix);
+  EXPECT_TRUE(add_full_hashes_result.empty());
+}
+
+// Test that deletes delete the chunk's data.
+TEST_F(SafeBrowsingStoreFileTest, DeleteChunks) {
+  EXPECT_TRUE(store_->BeginUpdate());
+
+  const base::Time now = base::Time::Now();
+
+  // A chunk which will be deleted.
+  EXPECT_FALSE(store_->CheckAddChunk(kAddChunk1));
+  store_->SetAddChunk(kAddChunk1);
+  EXPECT_TRUE(store_->BeginChunk());
+  EXPECT_TRUE(store_->WriteAddPrefix(kAddChunk1, kHash1.prefix));
+  EXPECT_TRUE(store_->WriteAddPrefix(kAddChunk1, kHash2.prefix));
+  EXPECT_TRUE(store_->WriteAddHash(kAddChunk1, now, kHash2));
+  EXPECT_TRUE(store_->FinishChunk());
+
+  // Another which won't.
+  EXPECT_FALSE(store_->CheckAddChunk(kAddChunk2));
+  store_->SetAddChunk(kAddChunk2);
+  EXPECT_TRUE(store_->BeginChunk());
+  EXPECT_TRUE(store_->WriteAddPrefix(kAddChunk2, kHash3.prefix));
+  EXPECT_TRUE(store_->WriteAddHash(kAddChunk2, now, kHash3));
+  EXPECT_TRUE(store_->FinishChunk());
+
+  // A sub chunk to delete.
+  EXPECT_FALSE(store_->CheckSubChunk(kSubChunk1));
+  store_->SetSubChunk(kSubChunk1);
+  EXPECT_TRUE(store_->BeginChunk());
+  EXPECT_TRUE(store_->WriteSubPrefix(kSubChunk1, kAddChunk3, kHash4.prefix));
+  EXPECT_TRUE(store_->WriteSubHash(kSubChunk1, kAddChunk3, kHash4));
+  EXPECT_TRUE(store_->FinishChunk());
+
+  // A sub chunk to keep.
+  EXPECT_FALSE(store_->CheckSubChunk(kSubChunk2));
+  store_->SetSubChunk(kSubChunk2);
+  EXPECT_TRUE(store_->BeginChunk());
+  EXPECT_TRUE(store_->WriteSubPrefix(kSubChunk2, kAddChunk4, kHash5.prefix));
+  EXPECT_TRUE(store_->WriteSubHash(kSubChunk2, kAddChunk4, kHash5));
+  EXPECT_TRUE(store_->FinishChunk());
+
+  store_->DeleteAddChunk(kAddChunk1);
+  store_->DeleteSubChunk(kSubChunk1);
+
+  // Not actually deleted until finish.
+  EXPECT_TRUE(store_->CheckAddChunk(kAddChunk1));
+  EXPECT_TRUE(store_->CheckAddChunk(kAddChunk2));
+  EXPECT_TRUE(store_->CheckSubChunk(kSubChunk1));
+  EXPECT_TRUE(store_->CheckSubChunk(kSubChunk2));
+
+  std::vector<SBAddFullHash> pending_adds;
+  SBAddPrefixes add_prefixes_result;
+  std::vector<SBAddFullHash> add_full_hashes_result;
+
+  EXPECT_TRUE(store_->FinishUpdate(pending_adds,
+                                   &add_prefixes_result,
+                                   &add_full_hashes_result));
+
+  EXPECT_EQ(1U, add_prefixes_result.size());
+  EXPECT_EQ(kAddChunk2, add_prefixes_result[0].chunk_id);
+  EXPECT_EQ(kHash3.prefix, add_prefixes_result[0].prefix);
+  EXPECT_EQ(1U, add_full_hashes_result.size());
+  EXPECT_EQ(kAddChunk2, add_full_hashes_result[0].chunk_id);
+  EXPECT_EQ(now.ToTimeT(), add_full_hashes_result[0].received);
+  EXPECT_TRUE(SBFullHashEqual(kHash3, add_full_hashes_result[0].full_hash));
+
+  // Expected chunks are there in another update.
+  EXPECT_TRUE(store_->BeginUpdate());
+  EXPECT_FALSE(store_->CheckAddChunk(kAddChunk1));
+  EXPECT_TRUE(store_->CheckAddChunk(kAddChunk2));
+  EXPECT_FALSE(store_->CheckSubChunk(kSubChunk1));
+  EXPECT_TRUE(store_->CheckSubChunk(kSubChunk2));
+
+  // Delete them, too.
+  store_->DeleteAddChunk(kAddChunk2);
+  store_->DeleteSubChunk(kSubChunk2);
+
+  add_prefixes_result.clear();
+  add_full_hashes_result.clear();
+  EXPECT_TRUE(store_->FinishUpdate(pending_adds,
+                                   &add_prefixes_result,
+                                   &add_full_hashes_result));
+
+  // Expect no more chunks.
+  EXPECT_TRUE(store_->BeginUpdate());
+  EXPECT_FALSE(store_->CheckAddChunk(kAddChunk1));
+  EXPECT_FALSE(store_->CheckAddChunk(kAddChunk2));
+  EXPECT_FALSE(store_->CheckSubChunk(kSubChunk1));
+  EXPECT_FALSE(store_->CheckSubChunk(kSubChunk2));
+  add_prefixes_result.clear();
+  add_full_hashes_result.clear();
+  EXPECT_TRUE(store_->FinishUpdate(pending_adds,
+                                   &add_prefixes_result,
+                                   &add_full_hashes_result));
+  EXPECT_TRUE(add_prefixes_result.empty());
+  EXPECT_TRUE(add_full_hashes_result.empty());
+}
+
+// Test that deleting the store deletes the store.
+TEST_F(SafeBrowsingStoreFileTest, Delete) {
+  // Delete should work if the file wasn't there in the first place.
+  EXPECT_FALSE(base::PathExists(filename_));
+  EXPECT_TRUE(store_->Delete());
+
+  // Create a store file.
+  PopulateStore(base::Time::Now());
+
+  EXPECT_TRUE(base::PathExists(filename_));
+  EXPECT_TRUE(store_->Delete());
+  EXPECT_FALSE(base::PathExists(filename_));
+}
 
 // Test that Delete() deletes the temporary store, if present.
 TEST_F(SafeBrowsingStoreFileTest, DeleteTemp) {
@@ -77,7 +400,7 @@ TEST_F(SafeBrowsingStoreFileTest, DeleteTemp) {
 // Test basic corruption-handling.
 TEST_F(SafeBrowsingStoreFileTest, DetectsCorruption) {
   // Load a store with some data.
-  SafeBrowsingStoreTestStorePrefix(store_.get());
+  PopulateStore(base::Time::Now());
 
   // Can successfully open and read the store.
   std::vector<SBAddFullHash> pending_adds;
@@ -136,7 +459,7 @@ TEST_F(SafeBrowsingStoreFileTest, CheckValidity) {
 
   // A store with some data is valid.
   EXPECT_FALSE(base::PathExists(filename_));
-  SafeBrowsingStoreTestStorePrefix(store_.get());
+  PopulateStore(base::Time::Now());
   EXPECT_TRUE(base::PathExists(filename_));
   ASSERT_TRUE(store_->BeginUpdate());
   EXPECT_FALSE(corruption_detected_);
@@ -147,7 +470,7 @@ TEST_F(SafeBrowsingStoreFileTest, CheckValidity) {
 
 // Corrupt the payload.
 TEST_F(SafeBrowsingStoreFileTest, CheckValidityPayload) {
-  SafeBrowsingStoreTestStorePrefix(store_.get());
+  PopulateStore(base::Time::Now());
   EXPECT_TRUE(base::PathExists(filename_));
 
   // 37 is the most random prime number.  It's also past the header,
@@ -169,7 +492,7 @@ TEST_F(SafeBrowsingStoreFileTest, CheckValidityPayload) {
 
 // Corrupt the checksum.
 TEST_F(SafeBrowsingStoreFileTest, CheckValidityChecksum) {
-  SafeBrowsingStoreTestStorePrefix(store_.get());
+  PopulateStore(base::Time::Now());
   EXPECT_TRUE(base::PathExists(filename_));
 
   // An offset from the end of the file which is in the checksum.
diff --git a/chrome/browser/safe_browsing/safe_browsing_store_unittest_helper.cc b/chrome/browser/safe_browsing/safe_browsing_store_unittest_helper.cc
deleted file mode 100644
index 6ace70c..0000000
--- a/chrome/browser/safe_browsing/safe_browsing_store_unittest_helper.cc
+++ /dev/null
@@ -1,335 +0,0 @@
-// 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_unittest_helper.h"
-
-#include "base/file_util.h"
-
-namespace {
-
-const int kAddChunk1 = 1;
-const int kAddChunk2 = 3;
-const int kAddChunk3 = 5;
-const int kAddChunk4 = 7;
-// Disjoint chunk numbers for subs to flush out typos.
-const int kSubChunk1 = 2;
-const int kSubChunk2 = 4;
-
-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");
-
-}  // namespace
-
-void SafeBrowsingStoreTestEmpty(SafeBrowsingStore* store) {
-  EXPECT_TRUE(store->BeginUpdate());
-
-  std::vector<int> chunks;
-  store->GetAddChunks(&chunks);
-  EXPECT_TRUE(chunks.empty());
-  store->GetSubChunks(&chunks);
-  EXPECT_TRUE(chunks.empty());
-
-  // Shouldn't see anything, but anything is a big set to test.
-  EXPECT_FALSE(store->CheckAddChunk(0));
-  EXPECT_FALSE(store->CheckAddChunk(1));
-  EXPECT_FALSE(store->CheckAddChunk(-1));
-
-  EXPECT_FALSE(store->CheckSubChunk(0));
-  EXPECT_FALSE(store->CheckSubChunk(1));
-  EXPECT_FALSE(store->CheckSubChunk(-1));
-
-  std::vector<SBAddFullHash> pending_adds;
-  SBAddPrefixes add_prefixes_result;
-  std::vector<SBAddFullHash> add_full_hashes_result;
-
-  EXPECT_TRUE(store->FinishUpdate(pending_adds,
-                                  &add_prefixes_result,
-                                  &add_full_hashes_result));
-  EXPECT_TRUE(add_prefixes_result.empty());
-  EXPECT_TRUE(add_full_hashes_result.empty());
-}
-
-void SafeBrowsingStoreTestStorePrefix(SafeBrowsingStore* store) {
-  EXPECT_TRUE(store->BeginUpdate());
-
-  const base::Time now = base::Time::Now();
-
-  EXPECT_TRUE(store->BeginChunk());
-  store->SetAddChunk(kAddChunk1);
-  EXPECT_TRUE(store->CheckAddChunk(kAddChunk1));
-  EXPECT_TRUE(store->WriteAddPrefix(kAddChunk1, kHash1.prefix));
-  EXPECT_TRUE(store->WriteAddPrefix(kAddChunk1, kHash2.prefix));
-  EXPECT_TRUE(store->WriteAddHash(kAddChunk1, now, kHash2));
-
-  store->SetSubChunk(kSubChunk1);
-  EXPECT_TRUE(store->CheckSubChunk(kSubChunk1));
-  EXPECT_TRUE(store->WriteSubPrefix(kSubChunk1, kAddChunk3, kHash3.prefix));
-  EXPECT_TRUE(store->WriteSubHash(kSubChunk1, kAddChunk3, kHash3));
-  EXPECT_TRUE(store->FinishChunk());
-
-  // Chunk numbers shouldn't leak over.
-  EXPECT_FALSE(store->CheckAddChunk(kSubChunk1));
-  EXPECT_FALSE(store->CheckAddChunk(kAddChunk3));
-  EXPECT_FALSE(store->CheckSubChunk(kAddChunk1));
-
-  std::vector<int> chunks;
-  store->GetAddChunks(&chunks);
-  ASSERT_EQ(1U, chunks.size());
-  EXPECT_EQ(kAddChunk1, chunks[0]);
-
-  store->GetSubChunks(&chunks);
-  ASSERT_EQ(1U, chunks.size());
-  EXPECT_EQ(kSubChunk1, chunks[0]);
-
-  std::vector<SBAddFullHash> pending_adds;
-  SBAddPrefixes add_prefixes_result;
-  std::vector<SBAddFullHash> add_full_hashes_result;
-
-  EXPECT_TRUE(store->FinishUpdate(pending_adds,
-                                  &add_prefixes_result,
-                                  &add_full_hashes_result));
-
-  ASSERT_EQ(2U, add_prefixes_result.size());
-  EXPECT_EQ(kAddChunk1, add_prefixes_result[0].chunk_id);
-  EXPECT_EQ(kHash1.prefix, add_prefixes_result[0].prefix);
-  EXPECT_EQ(kAddChunk1, add_prefixes_result[1].chunk_id);
-  EXPECT_EQ(kHash2.prefix, add_prefixes_result[1].prefix);
-
-  ASSERT_EQ(1U, add_full_hashes_result.size());
-  EXPECT_EQ(kAddChunk1, add_full_hashes_result[0].chunk_id);
-  // EXPECT_TRUE(add_full_hashes_result[0].received == now)?
-  EXPECT_EQ(now.ToTimeT(), add_full_hashes_result[0].received);
-  EXPECT_TRUE(SBFullHashEqual(kHash2, add_full_hashes_result[0].full_hash));
-
-  add_prefixes_result.clear();
-  add_full_hashes_result.clear();
-
-  EXPECT_TRUE(store->BeginUpdate());
-
-  // Still has the chunks expected in the next update.
-  store->GetAddChunks(&chunks);
-  ASSERT_EQ(1U, chunks.size());
-  EXPECT_EQ(kAddChunk1, chunks[0]);
-
-  store->GetSubChunks(&chunks);
-  ASSERT_EQ(1U, chunks.size());
-  EXPECT_EQ(kSubChunk1, chunks[0]);
-
-  EXPECT_TRUE(store->CheckAddChunk(kAddChunk1));
-  EXPECT_TRUE(store->CheckSubChunk(kSubChunk1));
-
-  EXPECT_TRUE(store->FinishUpdate(pending_adds,
-                                  &add_prefixes_result,
-                                  &add_full_hashes_result));
-
-  // Still has the expected contents.
-  ASSERT_EQ(2U, add_prefixes_result.size());
-  EXPECT_EQ(kAddChunk1, add_prefixes_result[0].chunk_id);
-  EXPECT_EQ(kHash1.prefix, add_prefixes_result[0].prefix);
-  EXPECT_EQ(kAddChunk1, add_prefixes_result[1].chunk_id);
-  EXPECT_EQ(kHash2.prefix, add_prefixes_result[1].prefix);
-
-  ASSERT_EQ(1U, add_full_hashes_result.size());
-  EXPECT_EQ(kAddChunk1, add_full_hashes_result[0].chunk_id);
-  EXPECT_EQ(now.ToTimeT(), add_full_hashes_result[0].received);
-  EXPECT_TRUE(SBFullHashEqual(kHash2, add_full_hashes_result[0].full_hash));
-}
-
-void SafeBrowsingStoreTestSubKnockout(SafeBrowsingStore* store) {
-  EXPECT_TRUE(store->BeginUpdate());
-
-  const base::Time now = base::Time::Now();
-
-  EXPECT_TRUE(store->BeginChunk());
-  store->SetAddChunk(kAddChunk1);
-  EXPECT_TRUE(store->WriteAddPrefix(kAddChunk1, kHash1.prefix));
-  EXPECT_TRUE(store->WriteAddPrefix(kAddChunk1, kHash2.prefix));
-  EXPECT_TRUE(store->WriteAddHash(kAddChunk1, now, kHash2));
-
-  store->SetSubChunk(kSubChunk1);
-  EXPECT_TRUE(store->WriteSubPrefix(kSubChunk1, kAddChunk3, kHash3.prefix));
-  EXPECT_TRUE(store->WriteSubPrefix(kSubChunk1, kAddChunk1, kHash2.prefix));
-  EXPECT_TRUE(store->FinishChunk());
-
-  std::vector<SBAddFullHash> pending_adds;
-  SBAddPrefixes add_prefixes_result;
-  std::vector<SBAddFullHash> add_full_hashes_result;
-
-  EXPECT_TRUE(store->FinishUpdate(pending_adds,
-                                  &add_prefixes_result,
-                                  &add_full_hashes_result));
-
-  // Knocked out the chunk expected.
-  ASSERT_EQ(1U, add_prefixes_result.size());
-  EXPECT_EQ(kAddChunk1, add_prefixes_result[0].chunk_id);
-  EXPECT_EQ(kHash1.prefix, add_prefixes_result[0].prefix);
-  EXPECT_TRUE(add_full_hashes_result.empty());
-
-  add_prefixes_result.clear();
-
-  EXPECT_TRUE(store->BeginUpdate());
-
-  // This add should be knocked out by an existing sub.
-  EXPECT_TRUE(store->BeginChunk());
-  store->SetAddChunk(kAddChunk3);
-  EXPECT_TRUE(store->WriteAddPrefix(kAddChunk3, kHash3.prefix));
-  EXPECT_TRUE(store->FinishChunk());
-
-  EXPECT_TRUE(store->FinishUpdate(pending_adds,
-                                  &add_prefixes_result,
-                                  &add_full_hashes_result));
-  EXPECT_EQ(1U, add_prefixes_result.size());
-  EXPECT_EQ(kAddChunk1, add_prefixes_result[0].chunk_id);
-  EXPECT_EQ(kHash1.prefix, add_prefixes_result[0].prefix);
-  EXPECT_TRUE(add_full_hashes_result.empty());
-
-  add_prefixes_result.clear();
-
-  EXPECT_TRUE(store->BeginUpdate());
-
-  // But by here the sub should be gone, so it should stick this time.
-  EXPECT_TRUE(store->BeginChunk());
-  store->SetAddChunk(kAddChunk3);
-  EXPECT_TRUE(store->WriteAddPrefix(kAddChunk3, kHash3.prefix));
-  EXPECT_TRUE(store->FinishChunk());
-
-  EXPECT_TRUE(store->FinishUpdate(pending_adds,
-                                  &add_prefixes_result,
-                                  &add_full_hashes_result));
-  ASSERT_EQ(2U, add_prefixes_result.size());
-  EXPECT_EQ(kAddChunk1, add_prefixes_result[0].chunk_id);
-  EXPECT_EQ(kHash1.prefix, add_prefixes_result[0].prefix);
-  EXPECT_EQ(kAddChunk3, add_prefixes_result[1].chunk_id);
-  EXPECT_EQ(kHash3.prefix, add_prefixes_result[1].prefix);
-  EXPECT_TRUE(add_full_hashes_result.empty());
-}
-
-void SafeBrowsingStoreTestDeleteChunks(SafeBrowsingStore* store) {
-  EXPECT_TRUE(store->BeginUpdate());
-
-  const base::Time now = base::Time::Now();
-
-  // A chunk which will be deleted.
-  EXPECT_FALSE(store->CheckAddChunk(kAddChunk1));
-  store->SetAddChunk(kAddChunk1);
-  EXPECT_TRUE(store->BeginChunk());
-  EXPECT_TRUE(store->WriteAddPrefix(kAddChunk1, kHash1.prefix));
-  EXPECT_TRUE(store->WriteAddPrefix(kAddChunk1, kHash2.prefix));
-  EXPECT_TRUE(store->WriteAddHash(kAddChunk1, now, kHash2));
-  EXPECT_TRUE(store->FinishChunk());
-
-  // Another which won't.
-  EXPECT_FALSE(store->CheckAddChunk(kAddChunk2));
-  store->SetAddChunk(kAddChunk2);
-  EXPECT_TRUE(store->BeginChunk());
-  EXPECT_TRUE(store->WriteAddPrefix(kAddChunk2, kHash3.prefix));
-  EXPECT_TRUE(store->WriteAddHash(kAddChunk2, now, kHash3));
-  EXPECT_TRUE(store->FinishChunk());
-
-  // A sub chunk to delete.
-  EXPECT_FALSE(store->CheckSubChunk(kSubChunk1));
-  store->SetSubChunk(kSubChunk1);
-  EXPECT_TRUE(store->BeginChunk());
-  EXPECT_TRUE(store->WriteSubPrefix(kSubChunk1, kAddChunk3, kHash4.prefix));
-  EXPECT_TRUE(store->WriteSubHash(kSubChunk1, kAddChunk3, kHash4));
-  EXPECT_TRUE(store->FinishChunk());
-
-  // A sub chunk to keep.
-  EXPECT_FALSE(store->CheckSubChunk(kSubChunk2));
-  store->SetSubChunk(kSubChunk2);
-  EXPECT_TRUE(store->BeginChunk());
-  EXPECT_TRUE(store->WriteSubPrefix(kSubChunk2, kAddChunk4, kHash5.prefix));
-  EXPECT_TRUE(store->WriteSubHash(kSubChunk2, kAddChunk4, kHash5));
-  EXPECT_TRUE(store->FinishChunk());
-
-  store->DeleteAddChunk(kAddChunk1);
-  store->DeleteSubChunk(kSubChunk1);
-
-  // Not actually deleted until finish.
-  EXPECT_TRUE(store->CheckAddChunk(kAddChunk1));
-  EXPECT_TRUE(store->CheckAddChunk(kAddChunk2));
-  EXPECT_TRUE(store->CheckSubChunk(kSubChunk1));
-  EXPECT_TRUE(store->CheckSubChunk(kSubChunk2));
-
-  std::vector<SBAddFullHash> pending_adds;
-  SBAddPrefixes add_prefixes_result;
-  std::vector<SBAddFullHash> add_full_hashes_result;
-
-  EXPECT_TRUE(store->FinishUpdate(pending_adds,
-                                  &add_prefixes_result,
-                                  &add_full_hashes_result));
-
-  EXPECT_EQ(1U, add_prefixes_result.size());
-  EXPECT_EQ(kAddChunk2, add_prefixes_result[0].chunk_id);
-  EXPECT_EQ(kHash3.prefix, add_prefixes_result[0].prefix);
-  EXPECT_EQ(1U, add_full_hashes_result.size());
-  EXPECT_EQ(kAddChunk2, add_full_hashes_result[0].chunk_id);
-  EXPECT_EQ(now.ToTimeT(), add_full_hashes_result[0].received);
-  EXPECT_TRUE(SBFullHashEqual(kHash3, add_full_hashes_result[0].full_hash));
-
-  // Expected chunks are there in another update.
-  EXPECT_TRUE(store->BeginUpdate());
-  EXPECT_FALSE(store->CheckAddChunk(kAddChunk1));
-  EXPECT_TRUE(store->CheckAddChunk(kAddChunk2));
-  EXPECT_FALSE(store->CheckSubChunk(kSubChunk1));
-  EXPECT_TRUE(store->CheckSubChunk(kSubChunk2));
-
-  // Delete them, too.
-  store->DeleteAddChunk(kAddChunk2);
-  store->DeleteSubChunk(kSubChunk2);
-
-  add_prefixes_result.clear();
-  add_full_hashes_result.clear();
-  EXPECT_TRUE(store->FinishUpdate(pending_adds,
-                                  &add_prefixes_result,
-                                  &add_full_hashes_result));
-
-  // Expect no more chunks.
-  EXPECT_TRUE(store->BeginUpdate());
-  EXPECT_FALSE(store->CheckAddChunk(kAddChunk1));
-  EXPECT_FALSE(store->CheckAddChunk(kAddChunk2));
-  EXPECT_FALSE(store->CheckSubChunk(kSubChunk1));
-  EXPECT_FALSE(store->CheckSubChunk(kSubChunk2));
-  add_prefixes_result.clear();
-  add_full_hashes_result.clear();
-  EXPECT_TRUE(store->FinishUpdate(pending_adds,
-                                  &add_prefixes_result,
-                                  &add_full_hashes_result));
-  EXPECT_TRUE(add_prefixes_result.empty());
-  EXPECT_TRUE(add_full_hashes_result.empty());
-}
-
-void SafeBrowsingStoreTestDelete(SafeBrowsingStore* store,
-                                 const base::FilePath& filename) {
-  // Delete should work if the file wasn't there in the first place.
-  EXPECT_FALSE(base::PathExists(filename));
-  EXPECT_TRUE(store->Delete());
-
-  // Create a store file.
-  EXPECT_TRUE(store->BeginUpdate());
-
-  EXPECT_TRUE(store->BeginChunk());
-  store->SetAddChunk(kAddChunk1);
-  EXPECT_TRUE(store->WriteAddPrefix(kAddChunk1, kHash1.prefix));
-  EXPECT_TRUE(store->WriteAddPrefix(kAddChunk1, kHash2.prefix));
-
-  store->SetSubChunk(kSubChunk1);
-  EXPECT_TRUE(store->WriteSubPrefix(kSubChunk1, kAddChunk3, kHash3.prefix));
-  EXPECT_TRUE(store->FinishChunk());
-
-  std::vector<SBAddFullHash> pending_adds;
-  SBAddPrefixes add_prefixes_result;
-  std::vector<SBAddFullHash> add_full_hashes_result;
-
-  EXPECT_TRUE(store->FinishUpdate(pending_adds,
-                                  &add_prefixes_result,
-                                  &add_full_hashes_result));
-
-  EXPECT_TRUE(base::PathExists(filename));
-  EXPECT_TRUE(store->Delete());
-  EXPECT_FALSE(base::PathExists(filename));
-}
diff --git a/chrome/browser/safe_browsing/safe_browsing_store_unittest_helper.h b/chrome/browser/safe_browsing/safe_browsing_store_unittest_helper.h
deleted file mode 100644
index 589eb8e..0000000
--- a/chrome/browser/safe_browsing/safe_browsing_store_unittest_helper.h
+++ /dev/null
@@ -1,54 +0,0 @@
-// 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.
-
-#ifndef CHROME_BROWSER_SAFE_BROWSING_SAFE_BROWSING_STORE_UNITTEST_HELPER_H_
-#define CHROME_BROWSER_SAFE_BROWSING_SAFE_BROWSING_STORE_UNITTEST_HELPER_H_
-
-#include "chrome/browser/safe_browsing/safe_browsing_store.h"
-
-#include "testing/gtest/include/gtest/gtest.h"
-
-// Helper code for testing that a SafeBrowsingStore implementation
-// works to spec.
-
-// Test that the empty store looks empty.
-void SafeBrowsingStoreTestEmpty(SafeBrowsingStore* store);
-
-// Write some prefix data to the store and verify that it looks like
-// it is still there after the transaction completes.
-void SafeBrowsingStoreTestStorePrefix(SafeBrowsingStore* store);
-
-// Test that subs knockout adds.
-void SafeBrowsingStoreTestSubKnockout(SafeBrowsingStore* store);
-
-// Test that deletes delete the chunk's data.
-void SafeBrowsingStoreTestDeleteChunks(SafeBrowsingStore* store);
-
-// Test that deleting the store deletes the store.
-void SafeBrowsingStoreTestDelete(SafeBrowsingStore* store,
-                                 const base::FilePath& filename);
-
-// Wrap all the tests up for implementation subclasses.
-// |test_fixture| is the class that would be passed to TEST_F(),
-// |instance_name| is the name of the SafeBrowsingStore instance
-// within the class, as a pointer, and |filename| is that store's
-// filename, for the Delete() test.
-#define TEST_STORE(test_fixture, instance_name, filename)        \
-  TEST_F(test_fixture, Empty) { \
-    SafeBrowsingStoreTestEmpty(instance_name); \
-  } \
-  TEST_F(test_fixture, StorePrefix) { \
-    SafeBrowsingStoreTestStorePrefix(instance_name); \
-  } \
-  TEST_F(test_fixture, SubKnockout) { \
-    SafeBrowsingStoreTestSubKnockout(instance_name); \
-  } \
-  TEST_F(test_fixture, DeleteChunks) { \
-    SafeBrowsingStoreTestDeleteChunks(instance_name); \
-  } \
-  TEST_F(test_fixture, Delete) { \
-    SafeBrowsingStoreTestDelete(instance_name, filename);        \
-  }
-
-#endif  // CHROME_BROWSER_SAFE_BROWSING_SAFE_BROWSING_STORE_UNITTEST_HELPER_H_