Add ComputeMac and ComputeSplitMacs methods to pref_hash_store.

components/user_prefs/tracked/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 "components/user_prefs/tracked/pref_hash_store_impl.h"
 
 #include <string>
 
 #include "base/macros.h"
 #include "base/values.h"
 #include "components/user_prefs/tracked/dictionary_hash_store_contents.h"
 #include "components/user_prefs/tracked/hash_store_contents.h"
 #include "components/user_prefs/tracked/pref_hash_store_impl.h"
 #include "components/user_prefs/tracked/pref_hash_store_transaction.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 class PrefHashStoreImplTest : public testing::Test {
  protected:
   std::unique_ptr<HashStoreContents> CreateHashStoreContents() {
     return std::unique_ptr<HashStoreContents>(
         new DictionaryHashStoreContents(&pref_store_contents_));
   }
 
  private:
   base::DictionaryValue pref_store_contents_;
 };
 
+TEST_F(PrefHashStoreImplTest, ComputeMac) {
+  base::StringValue string_1("string1");
+  base::StringValue string_2("string2");
+  PrefHashStoreImpl pref_hash_store(std::string(32, 0), "device_id", true);
+
+  std::string computed_mac_1 = pref_hash_store.ComputeMac("path1", &string_1);
+  std::string computed_mac_2 = pref_hash_store.ComputeMac("path1", &string_2);
+  std::string computed_mac_3 = pref_hash_store.ComputeMac("path2", &string_1);
+
+  // Quick sanity checks here, see pref_hash_calculator_unittest.cc for more
+  // complete tests.

[gab, 2016/09/01 21:21:56]

Also

EXPECT_EQ(computed_mac_1, pref_hash_store.ComputeMac("path1", &string_1));

(i.e. same result twice in a row)

[proberge, 2016/09/06 18:43:39]

Done.

+  EXPECT_NE(computed_mac_1, computed_mac_2);
+  EXPECT_NE(computed_mac_1, computed_mac_3);
+  EXPECT_EQ(64, computed_mac_1.size());
+}
+
+TEST_F(PrefHashStoreImplTest, ComputeSplitMacs) {
+  base::DictionaryValue dict;
+  dict.Set("a", new base::StringValue("string1"));
+  dict.Set("b", new base::StringValue("string2"));
+  PrefHashStoreImpl pref_hash_store(std::string(32, 0), "device_id", true);
+
+  std::unique_ptr<base::DictionaryValue> computed_macs =
+      pref_hash_store.ComputeSplitMacs("foo.bar", &dict);
+
+  std::string mac_1;
+  std::string mac_2;
+  ASSERT_TRUE(computed_macs->GetString("a", &mac_1));
+  ASSERT_TRUE(computed_macs->GetString("b", &mac_2));
+
+  EXPECT_EQ(2, computed_macs->size());
+
+  base::StringValue string_1("string1");
+  base::StringValue string_2("string2");
+  EXPECT_EQ(pref_hash_store.ComputeMac("foo.bar.a", &string_1), mac_1);
+  EXPECT_EQ(pref_hash_store.ComputeMac("foo.bar.b", &string_2), mac_2);
+}
+
 TEST_F(PrefHashStoreImplTest, AtomicHashStoreAndCheck) {
   base::StringValue string_1("string1");
   base::StringValue string_2("string2");
 
   {
     // 32 NULL bytes is the seed that was used to generate the legacy hash.
     PrefHashStoreImpl pref_hash_store(std::string(32, 0), "device_id", true);
     std::unique_ptr<PrefHashStoreTransaction> transaction(
         pref_hash_store.BeginTransaction(CreateHashStoreContents()));
 
@@ skipping 427 matching lines @@
     // Load a new |pref_hash_store2| in which the hashes dictionary is trusted.
     PrefHashStoreImpl pref_hash_store2(std::string(32, 0), "device_id", true);
     std::unique_ptr<PrefHashStoreTransaction> transaction(
         pref_hash_store2.BeginTransaction(CreateHashStoreContents()));
     std::vector<std::string> invalid_keys;
     EXPECT_EQ(PrefHashStoreTransaction::TRUSTED_UNKNOWN_VALUE,
               transaction->CheckSplitValue("path1", &dict, &invalid_keys));
     EXPECT_TRUE(invalid_keys.empty());
   }
 }