Multi-strategy based tracking.

chrome/browser/prefs/pref_hash_store_impl_unittest.cc

 // Copyright 2013 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/prefs/pref_hash_store_impl.h"
 
 #include <string>
 
 #include "base/prefs/pref_service.h"
 #include "base/prefs/scoped_user_pref_update.h"
 #include "base/prefs/testing_pref_service.h"
 #include "base/values.h"
 #include "chrome/browser/prefs/pref_hash_store.h"
 #include "chrome/common/pref_names.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
-TEST(PrefHashStoreImplTest, TestCase) {
+TEST(PrefHashStoreImplTest, AtomicHashStoreAndCheck) {
   base::StringValue string_1("string1");
   base::StringValue string_2("string2");
 
   TestingPrefServiceSimple local_state;
   PrefHashStoreImpl::RegisterPrefs(local_state.registry());
 
   // 32 NULL bytes is the seed that was used to generate the legacy hash.
   PrefHashStoreImpl pref_hash_store(
-      "store_id", std::string(32,0), "device_id", &local_state);
+      "store_id", std::string(32, 0), "device_id", &local_state);
 
   ASSERT_EQ(PrefHashStore::UNKNOWN_VALUE,
             pref_hash_store.CheckValue("path1", &string_1));
   pref_hash_store.StoreHash("path1", &string_1);
   ASSERT_EQ(PrefHashStore::UNCHANGED,
             pref_hash_store.CheckValue("path1", &string_1));
   ASSERT_EQ(PrefHashStore::CLEARED, pref_hash_store.CheckValue("path1", NULL));
   pref_hash_store.StoreHash("path1", NULL);
   ASSERT_EQ(PrefHashStore::UNCHANGED,
             pref_hash_store.CheckValue("path1", NULL));
   ASSERT_EQ(PrefHashStore::CHANGED,
             pref_hash_store.CheckValue("path1", &string_2));
 
-  DictionaryValue dict;
+  base::DictionaryValue dict;
   dict.Set("a", new StringValue("foo"));
   dict.Set("d", new StringValue("bad"));
   dict.Set("b", new StringValue("bar"));
   dict.Set("c", new StringValue("baz"));
 
   // Manually shove in a legacy hash.
   DictionaryPrefUpdate update(&local_state, prefs::kProfilePreferenceHashes);
-  DictionaryValue* child_dictionary = NULL;
+  base::DictionaryValue* child_dictionary = NULL;
   ASSERT_TRUE(update->GetDictionary("store_id", &child_dictionary));
   child_dictionary->SetString(
       "path1",
       "C503FB7C65EEFD5C07185F616A0AA67923C069909933F362022B1F187E73E9A2");
 
   ASSERT_EQ(PrefHashStore::MIGRATED,
             pref_hash_store.CheckValue("path1", &dict));
   pref_hash_store.StoreHash("path1", &dict);
   ASSERT_EQ(PrefHashStore::UNCHANGED,
             pref_hash_store.CheckValue("path1", &dict));
 }
+
+TEST(PrefHashStoreImplTest, SplitHashStoreAndCheck) {
+  base::DictionaryValue dict;
+  dict.Set("a", new StringValue("to be replaced"));
+  dict.Set("b", new StringValue("same"));
+  dict.Set("o", new StringValue("old"));
+
+  base::DictionaryValue modified_dict;
+  modified_dict.Set("a", new StringValue("replaced"));
+  modified_dict.Set("b", new StringValue("same"));
+  modified_dict.Set("c", new StringValue("new"));
+
+  base::DictionaryValue empty_dict;
+
+  TestingPrefServiceSimple local_state;
+  PrefHashStoreImpl::RegisterPrefs(local_state.registry());
+
+  PrefHashStoreImpl pref_hash_store(
+      "store_id", std::string(32, 0), "device_id", &local_state);
+
+  std::vector<std::string> invalid_keys;
+
+  // No hashes stored yet.
+  ASSERT_EQ(PrefHashStore::UNKNOWN_VALUE,
+            pref_hash_store.CheckSplitValue("path1", &dict, &invalid_keys));
+  ASSERT_TRUE(invalid_keys.empty());
+
+  pref_hash_store.StoreSplitHash("path1", &dict);
+
+  // Verify match post storage.
+  ASSERT_EQ(PrefHashStore::UNCHANGED,
+            pref_hash_store.CheckSplitValue("path1", &dict, &invalid_keys));
+  ASSERT_TRUE(invalid_keys.empty());
+
+  // Verify new path is still unknown.
+  ASSERT_EQ(PrefHashStore::UNKNOWN_VALUE,
+            pref_hash_store.CheckSplitValue("path2", &dict, &invalid_keys));
+  ASSERT_TRUE(invalid_keys.empty());
+
+  // Verify NULL or empty dicts are declared as having been cleared.
+  ASSERT_EQ(PrefHashStore::CLEARED,
+            pref_hash_store.CheckSplitValue("path1", NULL, &invalid_keys));
+  ASSERT_TRUE(invalid_keys.empty());
+  ASSERT_EQ(PrefHashStore::CLEARED,
+            pref_hash_store.CheckSplitValue("path1", &empty_dict,
+                                           &invalid_keys));
+  ASSERT_TRUE(invalid_keys.empty());
+
+  // Verify changes are properly detected.
+  ASSERT_EQ(PrefHashStore::CHANGED,
+            pref_hash_store.CheckSplitValue("path1", &modified_dict,
+                                            &invalid_keys));
+  std::vector<std::string> expected_invalid_keys1;
+  expected_invalid_keys1.push_back("a");
+  expected_invalid_keys1.push_back("c");
+  ASSERT_EQ(expected_invalid_keys1, invalid_keys);
+  invalid_keys.clear();
+
+  // Verify still match post check.
+  ASSERT_EQ(PrefHashStore::UNCHANGED,
+            pref_hash_store.CheckSplitValue("path1", &dict, &invalid_keys));
+  ASSERT_TRUE(invalid_keys.empty());
+
+  pref_hash_store.StoreSplitHash("path1", &modified_dict);
+
+  // Verify |modified_dict| is now the one that verifies correctly.
+  ASSERT_EQ(PrefHashStore::UNCHANGED,
+            pref_hash_store.CheckSplitValue("path1", &modified_dict,
+                                            &invalid_keys));
+  ASSERT_TRUE(invalid_keys.empty());
+
+  // Verify old dict no longer matches.
+  ASSERT_EQ(PrefHashStore::CHANGED,
+            pref_hash_store.CheckSplitValue("path1", &dict, &invalid_keys));
+  std::vector<std::string> expected_invalid_keys2;
+  expected_invalid_keys2.push_back("a");
+  expected_invalid_keys2.push_back("o");
+  ASSERT_EQ(expected_invalid_keys2, invalid_keys);
+  invalid_keys.clear();
+
+  // Verify stored empty dictionary matches NULL and empty dictionary back.
+  pref_hash_store.StoreSplitHash("path1", &empty_dict);
+  ASSERT_EQ(PrefHashStore::UNCHANGED,
+            pref_hash_store.CheckSplitValue("path1", NULL, &invalid_keys));
+  ASSERT_TRUE(invalid_keys.empty());
+  ASSERT_EQ(PrefHashStore::UNCHANGED,
+            pref_hash_store.CheckSplitValue("path1", &empty_dict,
+                                           &invalid_keys));
+  ASSERT_TRUE(invalid_keys.empty());
+
+  // Same when storing NULL directly.
+  pref_hash_store.StoreSplitHash("path1", NULL);
+  ASSERT_EQ(PrefHashStore::UNCHANGED,
+            pref_hash_store.CheckSplitValue("path1", NULL, &invalid_keys));
+  ASSERT_TRUE(invalid_keys.empty());
+  ASSERT_EQ(PrefHashStore::UNCHANGED,
+            pref_hash_store.CheckSplitValue("path1", &empty_dict,
+                                           &invalid_keys));
+  ASSERT_TRUE(invalid_keys.empty());
+}