Safebrowsing: change gethash caching to match api 2.3 rules, fix some corner cases.

chrome/browser/safe_browsing/safe_browsing_store_file_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/safe_browsing_store_file.h"
 
 #include "base/bind.h"
 #include "base/file_util.h"
 #include "base/files/scoped_file.h"
 #include "base/files/scoped_temp_dir.h"
@@ skipping 44 matching lines @@
     store_.reset();
 
     PlatformTest::TearDown();
   }
 
   void OnCorruptionDetected() {
     corruption_detected_ = true;
   }
 
   // Populate the store with some testing data.
-  void PopulateStore(const base::Time& now) {
+  void PopulateStore() {
     ASSERT_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));
+    EXPECT_TRUE(store_->WriteAddHash(kAddChunk1, 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;
     safe_browsing::PrefixSetBuilder builder;
     std::vector<SBAddFullHash> add_full_hashes_result;
 
-    EXPECT_TRUE(store_->FinishUpdate(pending_adds,
-                                     &builder,
-                                     &add_full_hashes_result));
+    EXPECT_TRUE(store_->FinishUpdate(&builder, &add_full_hashes_result));
   }
 
   // Manually read the shard stride info from the file.
   uint32 ReadStride() {
     base::ScopedFILE file(base::OpenFile(filename_, "rb"));
     const long kOffset = 4 * sizeof(uint32);
     EXPECT_EQ(fseek(file.get(), kOffset, SEEK_SET), 0);
     uint32 shard_stride = 0;
     EXPECT_EQ(fread(&shard_stride, sizeof(shard_stride), 1, file.get()), 1U);
     return shard_stride;
@@ skipping 17 matching lines @@
 
   // 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;
   safe_browsing::PrefixSetBuilder builder;
   std::vector<SBAddFullHash> add_full_hashes_result;
 
-  EXPECT_TRUE(store_->FinishUpdate(pending_adds,
-                                   &builder,
-                                   &add_full_hashes_result));
+  EXPECT_TRUE(store_->FinishUpdate(&builder, &add_full_hashes_result));
   EXPECT_TRUE(add_full_hashes_result.empty());
 
   std::vector<SBPrefix> prefixes_result;
   builder.GetPrefixSet()->GetPrefixes(&prefixes_result);
   EXPECT_TRUE(prefixes_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);
+  PopulateStore();
 
   ASSERT_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;
     safe_browsing::PrefixSetBuilder builder;
     std::vector<SBAddFullHash> add_full_hashes_result;
-    EXPECT_TRUE(store_->FinishUpdate(pending_adds,
-                                     &builder,
-                                     &add_full_hashes_result));
+    EXPECT_TRUE(store_->FinishUpdate(&builder, &add_full_hashes_result));
 
     std::vector<SBPrefix> prefixes_result;
     builder.GetPrefixSet()->GetPrefixes(&prefixes_result);
     ASSERT_EQ(2U, prefixes_result.size());
     EXPECT_EQ(kHash1.prefix, prefixes_result[0]);
     EXPECT_EQ(kHash2.prefix, prefixes_result[1]);
 
     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));
   }
 
   ASSERT_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));
 
   {
-    std::vector<SBAddFullHash> pending_adds;
     safe_browsing::PrefixSetBuilder builder;
     std::vector<SBAddFullHash> add_full_hashes_result;
-    EXPECT_TRUE(store_->FinishUpdate(pending_adds,
-                                     &builder,
-                                     &add_full_hashes_result));
+    EXPECT_TRUE(store_->FinishUpdate(&builder, &add_full_hashes_result));
 
     // Still has the expected contents.
     std::vector<SBPrefix> prefixes_result;
     builder.GetPrefixSet()->GetPrefixes(&prefixes_result);
     ASSERT_EQ(2U, prefixes_result.size());
     EXPECT_EQ(kHash1.prefix, prefixes_result[0]);
     EXPECT_EQ(kHash2.prefix, prefixes_result[1]);
 
     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));
   }
 }
 
 // Verify that the min and max prefixes are stored and operated on.
 TEST_F(SafeBrowsingStoreFileTest, PrefixMinMax) {
-  const base::Time now = base::Time::Now();
-  PopulateStore(now);
+  PopulateStore();
 
   ASSERT_TRUE(store_->BeginUpdate());
 
   EXPECT_TRUE(store_->BeginChunk());
   store_->SetAddChunk(kAddChunk2);
   EXPECT_TRUE(store_->WriteAddPrefix(kAddChunk2, kMinSBPrefix));
   EXPECT_TRUE(store_->WriteAddPrefix(kAddChunk2, kMaxSBPrefix));
   EXPECT_TRUE(store_->FinishChunk());
 
   {
-    std::vector<SBAddFullHash> pending_adds;
     safe_browsing::PrefixSetBuilder builder;
     std::vector<SBAddFullHash> add_full_hashes_result;
-    EXPECT_TRUE(store_->FinishUpdate(pending_adds,
-                                     &builder,
-                                     &add_full_hashes_result));
+    EXPECT_TRUE(store_->FinishUpdate(&builder, &add_full_hashes_result));
 
     std::vector<SBPrefix> prefixes_result;
     builder.GetPrefixSet()->GetPrefixes(&prefixes_result);
     ASSERT_EQ(4U, prefixes_result.size());
     EXPECT_EQ(kMinSBPrefix, prefixes_result[0]);
     EXPECT_EQ(kHash1.prefix, prefixes_result[1]);
     EXPECT_EQ(kHash2.prefix, prefixes_result[2]);
     EXPECT_EQ(kMaxSBPrefix, prefixes_result[3]);
   }
 
   ASSERT_TRUE(store_->BeginUpdate());
 
   EXPECT_TRUE(store_->BeginChunk());
   store_->SetAddChunk(kSubChunk2);
   EXPECT_TRUE(store_->WriteSubPrefix(kSubChunk2, kAddChunk2, kMinSBPrefix));
   EXPECT_TRUE(store_->WriteSubPrefix(kSubChunk2, kAddChunk2, kMaxSBPrefix));
   EXPECT_TRUE(store_->FinishChunk());
 
   {
-    std::vector<SBAddFullHash> pending_adds;
     safe_browsing::PrefixSetBuilder builder;
     std::vector<SBAddFullHash> add_full_hashes_result;
-    EXPECT_TRUE(store_->FinishUpdate(pending_adds,
-                                     &builder,
-                                     &add_full_hashes_result));
+    EXPECT_TRUE(store_->FinishUpdate(&builder, &add_full_hashes_result));
 
     std::vector<SBPrefix> prefixes_result;
     builder.GetPrefixSet()->GetPrefixes(&prefixes_result);
     ASSERT_EQ(2U, prefixes_result.size());
     EXPECT_EQ(kHash1.prefix, prefixes_result[0]);
     EXPECT_EQ(kHash2.prefix, prefixes_result[1]);
   }
 }
 
 // Test that subs knockout adds.
 TEST_F(SafeBrowsingStoreFileTest, SubKnockout) {
   ASSERT_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));
+  EXPECT_TRUE(store_->WriteAddHash(kAddChunk1, 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;
     safe_browsing::PrefixSetBuilder builder;
     std::vector<SBAddFullHash> add_full_hashes_result;
-    EXPECT_TRUE(store_->FinishUpdate(pending_adds,
-                                     &builder,
-                                     &add_full_hashes_result));
+    EXPECT_TRUE(store_->FinishUpdate(&builder, &add_full_hashes_result));
 
     // Knocked out the chunk expected.
     std::vector<SBPrefix> prefixes_result;
     builder.GetPrefixSet()->GetPrefixes(&prefixes_result);
     ASSERT_EQ(1U, prefixes_result.size());
     EXPECT_EQ(kHash1.prefix, prefixes_result[0]);
     EXPECT_TRUE(add_full_hashes_result.empty());
   }
 
   ASSERT_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());
 
   {
-    std::vector<SBAddFullHash> pending_adds;
     safe_browsing::PrefixSetBuilder builder;
     std::vector<SBAddFullHash> add_full_hashes_result;
-    EXPECT_TRUE(store_->FinishUpdate(pending_adds,
-                                     &builder,
-                                     &add_full_hashes_result));
+    EXPECT_TRUE(store_->FinishUpdate(&builder, &add_full_hashes_result));
 
     std::vector<SBPrefix> prefixes_result;
     builder.GetPrefixSet()->GetPrefixes(&prefixes_result);
     EXPECT_EQ(1U, prefixes_result.size());
     EXPECT_EQ(kHash1.prefix, prefixes_result[0]);
     EXPECT_TRUE(add_full_hashes_result.empty());
   }
 
   ASSERT_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());
 
   {
-    std::vector<SBAddFullHash> pending_adds;
     safe_browsing::PrefixSetBuilder builder;
     std::vector<SBAddFullHash> add_full_hashes_result;
-    EXPECT_TRUE(store_->FinishUpdate(pending_adds,
-                                     &builder,
-                                     &add_full_hashes_result));
+    EXPECT_TRUE(store_->FinishUpdate(&builder, &add_full_hashes_result));
 
     std::vector<SBPrefix> prefixes_result;
     builder.GetPrefixSet()->GetPrefixes(&prefixes_result);
     ASSERT_EQ(2U, prefixes_result.size());
     EXPECT_EQ(kHash1.prefix, prefixes_result[0]);
     EXPECT_EQ(kHash3.prefix, prefixes_result[1]);
     EXPECT_TRUE(add_full_hashes_result.empty());
   }
 }
 
 // Test that deletes delete the chunk's data.
 TEST_F(SafeBrowsingStoreFileTest, DeleteChunks) {
   ASSERT_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_->WriteAddHash(kAddChunk1, 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_->WriteAddHash(kAddChunk2, 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;
     safe_browsing::PrefixSetBuilder builder;
     std::vector<SBAddFullHash> add_full_hashes_result;
-    EXPECT_TRUE(store_->FinishUpdate(pending_adds,
-                                     &builder,
-                                     &add_full_hashes_result));
+    EXPECT_TRUE(store_->FinishUpdate(&builder, &add_full_hashes_result));
 
     std::vector<SBPrefix> prefixes_result;
     builder.GetPrefixSet()->GetPrefixes(&prefixes_result);
     EXPECT_EQ(1U, prefixes_result.size());
     EXPECT_EQ(kHash3.prefix, prefixes_result[0]);
 
     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.
   ASSERT_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);
 
   {
-    std::vector<SBAddFullHash> pending_adds;
     safe_browsing::PrefixSetBuilder builder;
     std::vector<SBAddFullHash> add_full_hashes_result;
-    EXPECT_TRUE(store_->FinishUpdate(pending_adds,
-                                     &builder,
-                                     &add_full_hashes_result));
+    EXPECT_TRUE(store_->FinishUpdate(&builder, &add_full_hashes_result));
   }
 
   // Expect no more chunks.
   ASSERT_TRUE(store_->BeginUpdate());
   EXPECT_FALSE(store_->CheckAddChunk(kAddChunk1));
   EXPECT_FALSE(store_->CheckAddChunk(kAddChunk2));
   EXPECT_FALSE(store_->CheckSubChunk(kSubChunk1));
   EXPECT_FALSE(store_->CheckSubChunk(kSubChunk2));
 
   {
-    std::vector<SBAddFullHash> pending_adds;
     safe_browsing::PrefixSetBuilder builder;
     std::vector<SBAddFullHash> add_full_hashes_result;
-    EXPECT_TRUE(store_->FinishUpdate(pending_adds,
-                                     &builder,
-                                     &add_full_hashes_result));
+    EXPECT_TRUE(store_->FinishUpdate(&builder, &add_full_hashes_result));
 
     std::vector<SBPrefix> prefixes_result;
     builder.GetPrefixSet()->GetPrefixes(&prefixes_result);
     EXPECT_TRUE(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());
+  PopulateStore();
 
   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) {
   const base::FilePath temp_file =
       SafeBrowsingStoreFile::TemporaryFileForFilename(filename_);
@@ skipping 14 matching lines @@
 
   // Make sure the temporary file is deleted.
   EXPECT_TRUE(store_->Delete());
   EXPECT_FALSE(base::PathExists(filename_));
   EXPECT_FALSE(base::PathExists(temp_file));
 }
 
 // Test basic corruption-handling.
 TEST_F(SafeBrowsingStoreFileTest, DetectsCorruption) {
   // Load a store with some data.
-  PopulateStore(base::Time::Now());
+  PopulateStore();
 
   // Can successfully open and read the store.
   {
-    std::vector<SBAddFullHash> pending_adds;
     std::vector<SBPrefix> orig_prefixes;
     std::vector<SBAddFullHash> orig_hashes;
     safe_browsing::PrefixSetBuilder builder;
     ASSERT_TRUE(store_->BeginUpdate());
-    EXPECT_TRUE(store_->FinishUpdate(pending_adds, &builder, &orig_hashes));
+    EXPECT_TRUE(store_->FinishUpdate(&builder, &orig_hashes));
     builder.GetPrefixSet()->GetPrefixes(&orig_prefixes);
     EXPECT_GT(orig_prefixes.size(), 0U);
     EXPECT_GT(orig_hashes.size(), 0U);
     EXPECT_FALSE(corruption_detected_);
   }
 
   // Corrupt the store.
   base::ScopedFILE file(base::OpenFile(filename_, "rb+"));
   const long kOffset = 60;
   EXPECT_EQ(fseek(file.get(), kOffset, SEEK_SET), 0);
   const uint32 kZero = 0;
   uint32 previous = kZero;
   EXPECT_EQ(fread(&previous, sizeof(previous), 1, file.get()), 1U);
   EXPECT_NE(previous, kZero);
   EXPECT_EQ(fseek(file.get(), kOffset, SEEK_SET), 0);
   EXPECT_EQ(fwrite(&kZero, sizeof(kZero), 1, file.get()), 1U);
   file.reset();
 
   // Update fails and corruption callback is called.
   std::vector<SBAddFullHash> add_hashes;
   corruption_detected_ = false;
   {
-    std::vector<SBAddFullHash> pending_adds;
     safe_browsing::PrefixSetBuilder builder;
     ASSERT_TRUE(store_->BeginUpdate());
-    EXPECT_FALSE(store_->FinishUpdate(pending_adds, &builder, &add_hashes));
+    EXPECT_FALSE(store_->FinishUpdate(&builder, &add_hashes));
     EXPECT_TRUE(corruption_detected_);
   }
 
   // Make it look like there is a lot of add-chunks-seen data.
   const long kAddChunkCountOffset = 2 * sizeof(int32);
   const int32 kLargeCount = 1000 * 1000 * 1000;
   file.reset(base::OpenFile(filename_, "rb+"));
   EXPECT_EQ(fseek(file.get(), kAddChunkCountOffset, SEEK_SET), 0);
   EXPECT_EQ(fwrite(&kLargeCount, sizeof(kLargeCount), 1, file.get()), 1U);
   file.reset();
 
   // Detects corruption and fails to even begin the update.
   corruption_detected_ = false;
   EXPECT_FALSE(store_->BeginUpdate());
   EXPECT_TRUE(corruption_detected_);
 }
 
 TEST_F(SafeBrowsingStoreFileTest, CheckValidity) {
   // Empty store is valid.
   EXPECT_FALSE(base::PathExists(filename_));
   ASSERT_TRUE(store_->BeginUpdate());
   EXPECT_FALSE(corruption_detected_);
   EXPECT_TRUE(store_->CheckValidity());
   EXPECT_FALSE(corruption_detected_);
   EXPECT_TRUE(store_->CancelUpdate());
 
   // A store with some data is valid.
   EXPECT_FALSE(base::PathExists(filename_));
-  PopulateStore(base::Time::Now());
+  PopulateStore();
   EXPECT_TRUE(base::PathExists(filename_));
   ASSERT_TRUE(store_->BeginUpdate());
   EXPECT_FALSE(corruption_detected_);
   EXPECT_TRUE(store_->CheckValidity());
   EXPECT_FALSE(corruption_detected_);
   EXPECT_TRUE(store_->CancelUpdate());
 }
 
 // Corrupt the header.
 TEST_F(SafeBrowsingStoreFileTest, CheckValidityHeader) {
-  PopulateStore(base::Time::Now());
+  PopulateStore();
   EXPECT_TRUE(base::PathExists(filename_));
 
   // 37 is the most random prime number.  It's also past the initial header
   // struct, somewhere in the chunk list.
   const size_t kOffset = 37;
 
   {
     base::ScopedFILE file(base::OpenFile(filename_, "rb+"));
     EXPECT_EQ(0, fseek(file.get(), kOffset, SEEK_SET));
     EXPECT_GE(fputs("hello", file.get()), 0);
   }
   ASSERT_FALSE(store_->BeginUpdate());
   EXPECT_TRUE(corruption_detected_);
 }
 
 // Corrupt the prefix payload.
 TEST_F(SafeBrowsingStoreFileTest, CheckValidityPayload) {
-  PopulateStore(base::Time::Now());
+  PopulateStore();
   EXPECT_TRUE(base::PathExists(filename_));
 
   // 137 is the second most random prime number.  It's also past the header and
   // chunk-id area.  Corrupting the header would fail BeginUpdate() in which
   // case CheckValidity() cannot be called.
   const size_t kOffset = 137;
 
   {
     base::ScopedFILE file(base::OpenFile(filename_, "rb+"));
     EXPECT_EQ(0, fseek(file.get(), kOffset, SEEK_SET));
     EXPECT_GE(fputs("hello", file.get()), 0);
   }
   ASSERT_TRUE(store_->BeginUpdate());
   EXPECT_FALSE(corruption_detected_);
   EXPECT_FALSE(store_->CheckValidity());
   EXPECT_TRUE(corruption_detected_);
   EXPECT_TRUE(store_->CancelUpdate());
 }
 
 // Corrupt the checksum.
 TEST_F(SafeBrowsingStoreFileTest, CheckValidityChecksum) {
-  PopulateStore(base::Time::Now());
+  PopulateStore();
   EXPECT_TRUE(base::PathExists(filename_));
 
   // An offset from the end of the file which is in the checksum.
   const int kOffset = -static_cast<int>(sizeof(base::MD5Digest));
 
   {
     base::ScopedFILE file(base::OpenFile(filename_, "rb+"));
     EXPECT_EQ(0, fseek(file.get(), kOffset, SEEK_END));
     EXPECT_GE(fputs("hello", file.get()), 0);
   }
   ASSERT_TRUE(store_->BeginUpdate());
   EXPECT_FALSE(corruption_detected_);
   EXPECT_FALSE(store_->CheckValidity());
   EXPECT_TRUE(corruption_detected_);
   EXPECT_TRUE(store_->CancelUpdate());
 }
 
 TEST_F(SafeBrowsingStoreFileTest, GetAddPrefixesAndHashes) {
   ASSERT_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));
+  EXPECT_TRUE(store_->WriteAddHash(kAddChunk1, 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]);
 
   safe_browsing::PrefixSetBuilder builder;
   std::vector<SBAddFullHash> add_full_hashes_result;
-  EXPECT_TRUE(store_->FinishUpdate(std::vector<SBAddFullHash>(),
-                                   &builder,
-                                   &add_full_hashes_result));
+  EXPECT_TRUE(store_->FinishUpdate(&builder, &add_full_hashes_result));
 
   SBAddPrefixes add_prefixes;
   EXPECT_TRUE(store_->GetAddPrefixes(&add_prefixes));
   ASSERT_EQ(2U, add_prefixes.size());
   EXPECT_EQ(kAddChunk1, add_prefixes[0].chunk_id);
   EXPECT_EQ(kHash1.prefix, add_prefixes[0].prefix);
   EXPECT_EQ(kAddChunk1, add_prefixes[1].chunk_id);
   EXPECT_EQ(kHash2.prefix, add_prefixes[1].prefix);
 
   std::vector<SBAddFullHash> add_hashes;
@@ skipping 24 matching lines @@
     ASSERT_TRUE(store_->BeginUpdate());
 
     EXPECT_TRUE(store_->BeginChunk());
     store_->SetAddChunk(chunk_id);
     EXPECT_TRUE(store_->CheckAddChunk(chunk_id));
     for (size_t i = 0; i < kPrefixesPerChunk; ++i) {
       EXPECT_TRUE(store_->WriteAddPrefix(chunk_id, static_cast<SBPrefix>(i)));
     }
     EXPECT_TRUE(store_->FinishChunk());
 
-    std::vector<SBAddFullHash> pending_adds;
     safe_browsing::PrefixSetBuilder builder;
     std::vector<SBAddFullHash> add_full_hashes_result;
-    EXPECT_TRUE(store_->FinishUpdate(pending_adds,
-                                     &builder,
-                                     &add_full_hashes_result));
+    EXPECT_TRUE(store_->FinishUpdate(&builder, &add_full_hashes_result));
 
     SBAddPrefixes add_prefixes;
     EXPECT_TRUE(store_->GetAddPrefixes(&add_prefixes));
     ASSERT_EQ(chunk_id * kPrefixesPerChunk, add_prefixes.size());
 
     // New stride should be the same, or shifted one right.
     const uint32 new_shard_stride = ReadStride();
     EXPECT_TRUE((new_shard_stride == shard_stride) ||
                 ((new_shard_stride << 1) == shard_stride));
     shard_stride = new_shard_stride;
     ++chunk_id;
   } while (!shard_stride || shard_stride > kTargetStride);
 
   // Guard against writing too many chunks.  If this gets too big, adjust
   // |kPrefixesPerChunk|.
   EXPECT_LT(chunk_id, 20);
 
   // Remove each chunk and check that the stride goes back to 0.
   while (--chunk_id) {
     ASSERT_TRUE(store_->BeginUpdate());
     EXPECT_TRUE(store_->CheckAddChunk(chunk_id));
     EXPECT_FALSE(store_->CheckAddChunk(chunk_id + 1));
     store_->DeleteAddChunk(chunk_id);
 
-    std::vector<SBAddFullHash> pending_adds;
     safe_browsing::PrefixSetBuilder builder;
     std::vector<SBAddFullHash> add_full_hashes_result;
-    EXPECT_TRUE(store_->FinishUpdate(pending_adds,
-                                     &builder,
-                                     &add_full_hashes_result));
+    EXPECT_TRUE(store_->FinishUpdate(&builder, &add_full_hashes_result));
 
     // New stride should be the same, or shifted one left.
     const uint32 new_shard_stride = ReadStride();
     EXPECT_TRUE((new_shard_stride == shard_stride) ||
                 (new_shard_stride == (shard_stride << 1)));
     shard_stride = new_shard_stride;
   }
   EXPECT_EQ(0u, shard_stride);
 }
 
@@ skipping 52 matching lines @@
   EXPECT_TRUE(store_->CheckSubChunk(kSubChunk1));
 
   // Sub chunk kAddChunk1 hash kHash2.
   store_->SetSubChunk(kSubChunk2);
   EXPECT_TRUE(store_->CheckSubChunk(kSubChunk1));
   EXPECT_TRUE(store_->WriteSubPrefix(kSubChunk1, kAddChunk1, kHash2.prefix));
   EXPECT_TRUE(store_->WriteSubHash(kSubChunk1, kAddChunk1, kHash2));
   EXPECT_TRUE(store_->FinishChunk());
 
   {
-    std::vector<SBAddFullHash> pending_adds;
     safe_browsing::PrefixSetBuilder builder;
     std::vector<SBAddFullHash> add_full_hashes_result;
-    EXPECT_TRUE(store_->FinishUpdate(pending_adds,
-                                     &builder,
-                                     &add_full_hashes_result));
+    EXPECT_TRUE(store_->FinishUpdate(&builder, &add_full_hashes_result));
 
     // The sub'ed prefix and hash are gone.
     std::vector<SBPrefix> prefixes_result;
     builder.GetPrefixSet()->GetPrefixes(&prefixes_result);
     ASSERT_EQ(1U, prefixes_result.size());
     EXPECT_EQ(kHash1.prefix, prefixes_result[0]);
     EXPECT_TRUE(add_full_hashes_result.empty());
   }
 }
 #endif
 
 }  // namespace