Fix a race condition in preference metric reporting.

chrome/browser/prefs/pref_hash_calculator_unittest.cc

Index: chrome/browser/prefs/pref_hash_calculator_unittest.cc
diff --git a/chrome/browser/prefs/pref_hash_calculator_unittest.cc b/chrome/browser/prefs/pref_hash_calculator_unittest.cc
new file mode 100644
index 0000000000000000000000000000000000000000..1f5ad7ca660a3438d31540592c6e7ac9d5f7953d
--- /dev/null
+++ b/chrome/browser/prefs/pref_hash_calculator_unittest.cc
@@ -0,0 +1,124 @@
+// 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_calculator.h"
+
+#include <string>
+
+#include "base/values.h"
+#include "testing/gtest/include/gtest/gtest.h"
+
+TEST(PrefHashCalculatorTest, TestCurrentAlgorithm) {
+  base::StringValue string_value_1("string value 1");
+  base::StringValue string_value_2("string value 2");
+  base::DictionaryValue dictionary_value_1;
+  dictionary_value_1.SetInteger("int value", 1);
+  dictionary_value_1.Set("nested empty map", new DictionaryValue);
+  base::DictionaryValue dictionary_value_1_equivalent;
+  dictionary_value_1_equivalent.SetInteger("int value", 1);
+  base::DictionaryValue dictionary_value_2;
+  dictionary_value_2.SetInteger("int value", 2);
+
+  PrefHashCalculator calc1("seed1", "deviceid");
+  PrefHashCalculator calc1_dup("seed1", "deviceid");
+  PrefHashCalculator calc2("seed2", "deviceid");
+  PrefHashCalculator calc3("seed1", "deviceid2");
+
+  // Two calculators with same seed produce same hash.
+  ASSERT_EQ(calc1.Calculate("pref_path", &string_value_1),
+            calc1_dup.Calculate("pref_path", &string_value_1));
+  ASSERT_EQ(PrefHashCalculator::VALID,
+            calc1_dup.Validate(
+                "pref_path",
+                &string_value_1,
+                calc1.Calculate("pref_path", &string_value_1)));
+
+  // Different seeds, different hashes.
+  ASSERT_NE(calc1.Calculate("pref_path", &string_value_1),
+            calc2.Calculate("pref_path", &string_value_1));
+  ASSERT_EQ(PrefHashCalculator::INVALID,
+            calc2.Validate(
+                "pref_path",
+                &string_value_1,
+                calc1.Calculate("pref_path", &string_value_1)));
+
+  // Different device IDs, different hashes.
+  ASSERT_NE(calc1.Calculate("pref_path", &string_value_1),
+            calc3.Calculate("pref_path", &string_value_1));
+
+  // Different values, different hashes.
+  ASSERT_NE(calc1.Calculate("pref_path", &string_value_1),
+            calc1.Calculate("pref_path", &string_value_2));
+
+  // Different paths, different hashes.
+  ASSERT_NE(calc1.Calculate("pref_path", &string_value_1),
+            calc1.Calculate("pref_path_2", &string_value_1));
+
+  // Works for dictionaries.
+  ASSERT_EQ(calc1.Calculate("pref_path", &dictionary_value_1),
+            calc1.Calculate("pref_path", &dictionary_value_1));
+  ASSERT_NE(calc1.Calculate("pref_path", &dictionary_value_1),
+            calc1.Calculate("pref_path", &dictionary_value_2));
+
+  // Empty dictionary children are pruned.
+  ASSERT_EQ(calc1.Calculate("pref_path", &dictionary_value_1),
+            calc1.Calculate("pref_path", &dictionary_value_1_equivalent));
+
+  // NULL value is supported.
+  ASSERT_FALSE(calc1.Calculate("pref_path", NULL).empty());
+}
+
+// Tests the output against a known value to catch unexpected algorithm changes.
+TEST(PrefHashCalculatorTest, CatchHashChanges) {
+  const char* kDeviceId = "test_device_id1";
+  {
+    static const char kExpectedValue[] =
+        "5CE37D7EBCBC9BE510F0F5E7C326CA92C1673713C3717839610AEA1A217D8BB8";
+
+    base::ListValue list;
+    list.Set(0, new base::FundamentalValue(true));
+    list.Set(1, new base::FundamentalValue(100));
+    list.Set(2, new base::FundamentalValue(1.0));
+
+    // 32 NULL bytes is the seed that was used to generate the hash in old
+    // tests. Use it again to ensure that we haven't altered the algorithm.
+    EXPECT_EQ(PrefHashCalculator::VALID,
+              PrefHashCalculator(std::string(32u, 0), kDeviceId).Validate(
+                  "pref.path2", &list, kExpectedValue));
+  }
+  {
+    static const char kExpectedValue[] =
+        "A50FE7EB31BFBC32B8A27E71730AF15421178A9B5815644ACE174B18966735B9";
+
+    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"));
+
+    // 32 NULL bytes is the seed that was used to generate the hash in old
+    // tests. Use it again to ensure that we haven't altered the algorithm.
+    EXPECT_EQ(PrefHashCalculator::VALID,
+              PrefHashCalculator(std::string(32u, 0), kDeviceId).Validate(
+                  "pref.path1", &dict, kExpectedValue));
+  }
+}
+
+TEST(PrefHashCalculatorTest, TestLegacyAlgorithm) {
+  const char* kExpectedValue =
+      "C503FB7C65EEFD5C07185F616A0AA67923C069909933F362022B1F187E73E9A2";
+  const char* kDeviceId = "deviceid";
+
+  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"));
+
+  // 32 NULL bytes is the seed that was used to generate the legacy hash.
+  EXPECT_EQ(PrefHashCalculator::VALID_LEGACY,
+            PrefHashCalculator(std::string(32u, 0), kDeviceId).Validate(
+                "pref.path1", &dict, kExpectedValue));
+
+}