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

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 18 matching lines @@
   SBFullHash one, onetwo, two;
   memset(&one, 0, sizeof(one));
   memset(&onetwo, 0, sizeof(onetwo));
   memset(&two, 0, sizeof(two));
   one.prefix = 1;
   one.full_hash[sizeof(SBPrefix)] = 1;
   onetwo.prefix = 1;
   onetwo.full_hash[sizeof(SBPrefix)] = 2;
   two.prefix = 2;
 
-  const base::Time now = base::Time::Now();
-
   // prefix dominates.
-  EXPECT_TRUE(SBAddPrefixHashLess(SBAddFullHash(11, now, one),
-                                  SBAddFullHash(10, now, two)));
-  EXPECT_FALSE(SBAddPrefixHashLess(SBAddFullHash(11, now, two),
-                                   SBAddFullHash(10, now, one)));
+  EXPECT_TRUE(SBAddPrefixHashLess(SBAddFullHash(11, one),
+                                  SBAddFullHash(10, two)));
+  EXPECT_FALSE(SBAddPrefixHashLess(SBAddFullHash(11, two),
+                                   SBAddFullHash(10, one)));
 
   // After prefix, add_id.
-  EXPECT_TRUE(SBAddPrefixHashLess(SBAddFullHash(10, now, one),
-                                  SBAddFullHash(11, now, onetwo)));
-  EXPECT_FALSE(SBAddPrefixHashLess(SBAddFullHash(11, now, one),
-                                   SBAddFullHash(10, now, onetwo)));
+  EXPECT_TRUE(SBAddPrefixHashLess(SBAddFullHash(10, one),
+                                  SBAddFullHash(11, onetwo)));
+  EXPECT_FALSE(SBAddPrefixHashLess(SBAddFullHash(11, one),
+                                   SBAddFullHash(10, onetwo)));
 
   // After add_id, full hash.
-  EXPECT_TRUE(SBAddPrefixHashLess(SBAddFullHash(10, now, one),
-                                  SBAddFullHash(10, now, onetwo)));
-  EXPECT_FALSE(SBAddPrefixHashLess(SBAddFullHash(10, now, onetwo),
-                                   SBAddFullHash(10, now, one)));
+  EXPECT_TRUE(SBAddPrefixHashLess(SBAddFullHash(10, one),
+                                  SBAddFullHash(10, onetwo)));
+  EXPECT_FALSE(SBAddPrefixHashLess(SBAddFullHash(10, onetwo),
+                                   SBAddFullHash(10, one)));
 
   // Equal is not less-than.
-  EXPECT_FALSE(SBAddPrefixHashLess(SBAddFullHash(10, now, one),
-                                   SBAddFullHash(10, now, one)));
+  EXPECT_FALSE(SBAddPrefixHashLess(SBAddFullHash(10, one),
+                                   SBAddFullHash(10, one)));
 }
 
 TEST(SafeBrowsingStoreTest, SBSubPrefixLess) {
   // prefix dominates.
   EXPECT_TRUE(SBAddPrefixLess(SBSubPrefix(12, 11, 1), SBSubPrefix(9, 10, 2)));
   EXPECT_FALSE(SBAddPrefixLess(SBSubPrefix(12, 11, 2), SBSubPrefix(9, 10, 1)));
 
   // After prefix, add_id.
   EXPECT_TRUE(SBAddPrefixLess(SBSubPrefix(12, 9, 1), SBSubPrefix(9, 10, 1)));
   EXPECT_FALSE(SBAddPrefixLess(SBSubPrefix(12, 10, 1), SBSubPrefix(9, 9, 1)));
@@ skipping 50 matching lines @@
   SBProcessSubs(&add_prefixes, &sub_prefixes, &add_hashes, &sub_hashes,
                 no_deletions, no_deletions);
   EXPECT_TRUE(add_prefixes.empty());
   EXPECT_TRUE(sub_prefixes.empty());
   EXPECT_TRUE(add_hashes.empty());
   EXPECT_TRUE(sub_hashes.empty());
 }
 
 // Test that subs knock out adds.
 TEST(SafeBrowsingStoreTest, SBProcessSubsKnockout) {
-  const base::Time kNow = base::Time::Now();
   const SBFullHash kHash1(SBFullHashForString("one"));
   const SBFullHash kHash2(SBFullHashForString("two"));
   const SBFullHash kHash3(SBFullHashForString("three"));
   const SBFullHash kHash4(SBFullHashForString("four"));
   const int kAddChunk1 = 1;  // Use different chunk numbers just in case.
   const int kSubChunk1 = 2;
 
   // Construct some full hashes which share prefix with another.
   SBFullHash kHash1mod1 = kHash1;
   kHash1mod1.full_hash[sizeof(kHash1mod1.full_hash) - 1] ++;
   SBFullHash kHash1mod2 = kHash1mod1;
   kHash1mod2.full_hash[sizeof(kHash1mod2.full_hash) - 1] ++;
   SBFullHash kHash1mod3 = kHash1mod2;
   kHash1mod3.full_hash[sizeof(kHash1mod3.full_hash) - 1] ++;
 
   // A second full-hash for the full-hash-sub test.
   SBFullHash kHash4mod = kHash4;
   kHash4mod.full_hash[sizeof(kHash4mod.full_hash) - 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, plus a sub for the prefix
   // and a couple sub hashes.  The sub should knock all of them out.
   add_prefixes.push_back(SBAddPrefix(kAddChunk1, kHash1.prefix));
-  add_hashes.push_back(SBAddFullHash(kAddChunk1, kNow, kHash1));
-  add_hashes.push_back(SBAddFullHash(kAddChunk1, kNow, kHash1mod1));
+  add_hashes.push_back(SBAddFullHash(kAddChunk1, kHash1));
+  add_hashes.push_back(SBAddFullHash(kAddChunk1, kHash1mod1));
   sub_prefixes.push_back(SBSubPrefix(kSubChunk1, kAddChunk1, kHash1.prefix));
   sub_hashes.push_back(SBSubFullHash(kSubChunk1, kAddChunk1, kHash1mod2));
   sub_hashes.push_back(SBSubFullHash(kSubChunk1, kAddChunk1, kHash1mod3));
 
   // An add with no corresponding sub.  Both items should be retained.
-  add_hashes.push_back(SBAddFullHash(kAddChunk1, kNow, kHash2));
+  add_hashes.push_back(SBAddFullHash(kAddChunk1, kHash2));
   add_prefixes.push_back(SBAddPrefix(kAddChunk1, kHash2.prefix));
 
   // A sub with no corresponding add.  Both items should be retained.
   sub_hashes.push_back(SBSubFullHash(kSubChunk1, kAddChunk1, kHash3));
   sub_prefixes.push_back(SBSubPrefix(kSubChunk1, kAddChunk1, kHash3.prefix));
 
   // An add with prefix and a couple hashes, plus a sub for one of the
   // hashes.
   add_prefixes.push_back(SBAddPrefix(kAddChunk1, kHash4.prefix));
-  add_hashes.push_back(SBAddFullHash(kAddChunk1, kNow, kHash4));
-  add_hashes.push_back(SBAddFullHash(kAddChunk1, kNow, kHash4mod));
+  add_hashes.push_back(SBAddFullHash(kAddChunk1, kHash4));
+  add_hashes.push_back(SBAddFullHash(kAddChunk1, kHash4mod));
   sub_hashes.push_back(SBSubFullHash(kSubChunk1, kAddChunk1, kHash4mod));
 
   std::sort(add_prefixes.begin(), add_prefixes.end(),
             SBAddPrefixLess<SBAddPrefix,SBAddPrefix>);
   std::sort(sub_prefixes.begin(), sub_prefixes.end(),
             SBAddPrefixLess<SBSubPrefix,SBSubPrefix>);
   std::sort(add_hashes.begin(), add_hashes.end(),
             SBAddPrefixHashLess<SBAddFullHash,SBAddFullHash>);
   std::sort(sub_hashes.begin(), sub_hashes.end(),
             SBAddPrefixHashLess<SBSubFullHash,SBSubFullHash>);
@@ skipping 25 matching lines @@
   ASSERT_LE(1U, sub_hashes.size());
   EXPECT_EQ(1U, sub_hashes.size());
   EXPECT_EQ(kSubChunk1, sub_hashes[0].chunk_id);
   EXPECT_EQ(kAddChunk1, sub_hashes[0].add_chunk_id);
   EXPECT_TRUE(SBFullHashEqual(kHash3, sub_hashes[0].full_hash));
 }
 
 // Test chunk deletions, and ordering of deletions WRT subs knocking
 // out adds.
 TEST(SafeBrowsingStoreTest, SBProcessSubsDeleteChunk) {
-  const base::Time kNow = base::Time::Now();
   const SBFullHash kHash1(SBFullHashForString("one"));
   const SBFullHash kHash2(SBFullHashForString("two"));
   const SBFullHash kHash3(SBFullHashForString("three"));
   const int kAddChunk1 = 1;  // Use different chunk numbers just in case.
   const int kSubChunk1 = 2;
 
   // Construct some full hashes which share prefix with another.
   SBFullHash kHash1mod1 = kHash1;
   kHash1mod1.full_hash[sizeof(kHash1mod1.full_hash) - 1] ++;
   SBFullHash kHash1mod2 = kHash1mod1;
   kHash1mod2.full_hash[sizeof(kHash1mod2.full_hash) - 1] ++;
   SBFullHash kHash1mod3 = kHash1mod2;
   kHash1mod3.full_hash[sizeof(kHash1mod3.full_hash) - 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, plus a sub for the prefix
   // and a couple sub hashes.  The sub should knock all of them out.
   add_prefixes.push_back(SBAddPrefix(kAddChunk1, kHash1.prefix));
-  add_hashes.push_back(SBAddFullHash(kAddChunk1, kNow, kHash1));
-  add_hashes.push_back(SBAddFullHash(kAddChunk1, kNow, kHash1mod1));
+  add_hashes.push_back(SBAddFullHash(kAddChunk1, kHash1));
+  add_hashes.push_back(SBAddFullHash(kAddChunk1, kHash1mod1));
   sub_prefixes.push_back(SBSubPrefix(kSubChunk1, kAddChunk1, kHash1.prefix));
   sub_hashes.push_back(SBSubFullHash(kSubChunk1, kAddChunk1, kHash1mod2));
   sub_hashes.push_back(SBSubFullHash(kSubChunk1, kAddChunk1, kHash1mod3));
 
   // An add with no corresponding sub.  Both items should be retained.
-  add_hashes.push_back(SBAddFullHash(kAddChunk1, kNow, kHash2));
+  add_hashes.push_back(SBAddFullHash(kAddChunk1, kHash2));
   add_prefixes.push_back(SBAddPrefix(kAddChunk1, kHash2.prefix));
 
   // A sub with no corresponding add.  Both items should be retained.
   sub_hashes.push_back(SBSubFullHash(kSubChunk1, kAddChunk1, kHash3));
   sub_prefixes.push_back(SBSubPrefix(kSubChunk1, kAddChunk1, kHash3.prefix));
 
   std::sort(add_prefixes.begin(), add_prefixes.end(),
             SBAddPrefixLess<SBAddPrefix,SBAddPrefix>);
   std::sort(sub_prefixes.begin(), sub_prefixes.end(),
             SBAddPrefixLess<SBSubPrefix,SBSubPrefix>);
@@ skipping 44 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.";
 }
 
 }  // namespace