Make super MAC optional.

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/macros.h"
 #include "base/values.h"
@@ skipping 86 matching lines @@
   MockHashStoreContents::Data hash_store_data_;
 };
 
 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", CreateHashStoreContents());
+        std::string(32, 0), "device_id", CreateHashStoreContents(), true);
     scoped_ptr<PrefHashStoreTransaction> transaction(
         pref_hash_store.BeginTransaction());
 
     // Only NULL should be trusted in the absence of a hash.
     EXPECT_EQ(PrefHashStoreTransaction::UNTRUSTED_UNKNOWN_VALUE,
               transaction->CheckValue("path1", &string_1));
     EXPECT_EQ(PrefHashStoreTransaction::TRUSTED_UNKNOWN_VALUE,
               transaction->CheckValue("path1", NULL));
 
     transaction->StoreHash("path1", &string_1);
@@ skipping 24 matching lines @@
     EXPECT_EQ(PrefHashStoreTransaction::UNCHANGED,
               transaction->CheckValue("path1", &dict));
 
     // Test that the |pref_hash_store| flushes its changes on request post
     // transaction.
     transaction.reset();
     pref_hash_store.CommitPendingWrite();
     EXPECT_TRUE(hash_store_data_.GetCommitPerformedAndReset());
   }
 
+  ASSERT_FALSE(CreateHashStoreContents()->GetSuperMac().empty());
+
   {
     // |pref_hash_store2| should trust its initial hashes dictionary and thus
     // trust new unknown values.
     PrefHashStoreImpl pref_hash_store2(
-        std::string(32, 0), "device_id", CreateHashStoreContents());
+        std::string(32, 0), "device_id", CreateHashStoreContents(), true);
     scoped_ptr<PrefHashStoreTransaction> transaction(
         pref_hash_store2.BeginTransaction());
     EXPECT_EQ(PrefHashStoreTransaction::TRUSTED_UNKNOWN_VALUE,
               transaction->CheckValue("new_path", &string_1));
     EXPECT_EQ(PrefHashStoreTransaction::TRUSTED_UNKNOWN_VALUE,
               transaction->CheckValue("new_path", &string_2));
     EXPECT_EQ(PrefHashStoreTransaction::TRUSTED_UNKNOWN_VALUE,
               transaction->CheckValue("new_path", NULL));
 
     // Test that |pref_hash_store2| doesn't flush its contents to disk when it
     // didn't change.
     transaction.reset();
     pref_hash_store2.CommitPendingWrite();
     EXPECT_FALSE(hash_store_data_.GetCommitPerformedAndReset());
   }
 
   // Manually corrupt the super MAC.
   hash_store_data_.super_mac = std::string(64, 'A');
 
   {
     // |pref_hash_store3| should no longer trust its initial hashes dictionary
     // and thus shouldn't trust non-NULL unknown values.
     PrefHashStoreImpl pref_hash_store3(
-        std::string(32, 0), "device_id", CreateHashStoreContents());
+        std::string(32, 0), "device_id", CreateHashStoreContents(), true);
     scoped_ptr<PrefHashStoreTransaction> transaction(
         pref_hash_store3.BeginTransaction());
     EXPECT_EQ(PrefHashStoreTransaction::UNTRUSTED_UNKNOWN_VALUE,
               transaction->CheckValue("new_path", &string_1));
     EXPECT_EQ(PrefHashStoreTransaction::UNTRUSTED_UNKNOWN_VALUE,
               transaction->CheckValue("new_path", &string_2));
     EXPECT_EQ(PrefHashStoreTransaction::TRUSTED_UNKNOWN_VALUE,
               transaction->CheckValue("new_path", NULL));
 
     // Test that |pref_hash_store3| doesn't flush its contents to disk when it
     // didn't change.
     transaction.reset();
     pref_hash_store3.CommitPendingWrite();
     EXPECT_FALSE(hash_store_data_.GetCommitPerformedAndReset());
   }
 }
 
+TEST_F(PrefHashStoreImplTest, SuperMACDisabled) {
+  base::StringValue string_1("string1");
+  base::StringValue string_2("string2");
+
+  {
+    // Pass |use_super_mac| => false.
+    PrefHashStoreImpl pref_hash_store(
+        std::string(32, 0), "device_id", CreateHashStoreContents(), false);
+    scoped_ptr<PrefHashStoreTransaction> transaction(
+        pref_hash_store.BeginTransaction());
+
+    transaction->StoreHash("path1", &string_2);
+    EXPECT_EQ(PrefHashStoreTransaction::UNCHANGED,
+              transaction->CheckValue("path1", &string_2));
+  }
+
+  ASSERT_TRUE(CreateHashStoreContents()->GetSuperMac().empty());
+
+  {
+    PrefHashStoreImpl pref_hash_store2(
+        std::string(32, 0), "device_id", CreateHashStoreContents(), false);
+    scoped_ptr<PrefHashStoreTransaction> transaction(
+        pref_hash_store2.BeginTransaction());
+    EXPECT_EQ(PrefHashStoreTransaction::UNTRUSTED_UNKNOWN_VALUE,
+              transaction->CheckValue("new_path", &string_1));
+  }
+}
+
 TEST_F(PrefHashStoreImplTest, SplitHashStoreAndCheck) {
   base::DictionaryValue dict;
   dict.Set("a", new base::StringValue("to be replaced"));
   dict.Set("b", new base::StringValue("same"));
   dict.Set("o", new base::StringValue("old"));
 
   base::DictionaryValue modified_dict;
   modified_dict.Set("a", new base::StringValue("replaced"));
   modified_dict.Set("b", new base::StringValue("same"));
   modified_dict.Set("c", new base::StringValue("new"));
 
   base::DictionaryValue empty_dict;
 
   std::vector<std::string> invalid_keys;
 
   {
     PrefHashStoreImpl pref_hash_store(
-        std::string(32, 0), "device_id", CreateHashStoreContents());
+        std::string(32, 0), "device_id", CreateHashStoreContents(), true);
     scoped_ptr<PrefHashStoreTransaction> transaction(
         pref_hash_store.BeginTransaction());
 
     // No hashes stored yet and hashes dictionary is empty (and thus not
     // trusted).
     EXPECT_EQ(PrefHashStoreTransaction::UNTRUSTED_UNKNOWN_VALUE,
               transaction->CheckSplitValue("path1", &dict, &invalid_keys));
     EXPECT_TRUE(invalid_keys.empty());
 
     transaction->StoreSplitHash("path1", &dict);
@@ skipping 55 matching lines @@
     // Test that the |pref_hash_store| flushes its changes on request.
     transaction.reset();
     pref_hash_store.CommitPendingWrite();
     EXPECT_TRUE(hash_store_data_.GetCommitPerformedAndReset());
   }
 
   {
     // |pref_hash_store2| should trust its initial hashes dictionary and thus
     // trust new unknown values.
     PrefHashStoreImpl pref_hash_store2(
-        std::string(32, 0), "device_id", CreateHashStoreContents());
+        std::string(32, 0), "device_id", CreateHashStoreContents(), true);
     scoped_ptr<PrefHashStoreTransaction> transaction(
         pref_hash_store2.BeginTransaction());
     EXPECT_EQ(PrefHashStoreTransaction::TRUSTED_UNKNOWN_VALUE,
               transaction->CheckSplitValue("new_path", &dict, &invalid_keys));
     EXPECT_TRUE(invalid_keys.empty());
 
     // Test that |pref_hash_store2| doesn't flush its contents to disk when it
     // didn't change.
     transaction.reset();
     pref_hash_store2.CommitPendingWrite();
     EXPECT_FALSE(hash_store_data_.GetCommitPerformedAndReset());
   }
 
   // Manually corrupt the super MAC.
   hash_store_data_.super_mac = std::string(64, 'A');
 
   {
     // |pref_hash_store3| should no longer trust its initial hashes dictionary
     // and thus shouldn't trust unknown values.
     PrefHashStoreImpl pref_hash_store3(
-        std::string(32, 0), "device_id", CreateHashStoreContents());
+        std::string(32, 0), "device_id", CreateHashStoreContents(), true);
     scoped_ptr<PrefHashStoreTransaction> transaction(
         pref_hash_store3.BeginTransaction());
     EXPECT_EQ(PrefHashStoreTransaction::UNTRUSTED_UNKNOWN_VALUE,
               transaction->CheckSplitValue("new_path", &dict, &invalid_keys));
     EXPECT_TRUE(invalid_keys.empty());
 
     // Test that |pref_hash_store3| doesn't flush its contents to disk when it
     // didn't change.
     transaction.reset();
     pref_hash_store3.CommitPendingWrite();
     EXPECT_FALSE(hash_store_data_.GetCommitPerformedAndReset());
   }
 }
 
 TEST_F(PrefHashStoreImplTest, EmptyAndNULLSplitDict) {
   base::DictionaryValue empty_dict;
 
   std::vector<std::string> invalid_keys;
 
   {
     PrefHashStoreImpl pref_hash_store(
-        std::string(32, 0), "device_id", CreateHashStoreContents());
+        std::string(32, 0), "device_id", CreateHashStoreContents(), true);
     scoped_ptr<PrefHashStoreTransaction> transaction(
         pref_hash_store.BeginTransaction());
 
     // Store hashes for a random dict to be overwritten below.
     base::DictionaryValue initial_dict;
     initial_dict.Set("a", new base::StringValue("foo"));
     transaction->StoreSplitHash("path1", &initial_dict);
 
     // Verify stored empty dictionary matches NULL and empty dictionary back.
     transaction->StoreSplitHash("path1", &empty_dict);
@@ skipping 16 matching lines @@
     EXPECT_TRUE(invalid_keys.empty());
   }
 
   {
     // |pref_hash_store2| should trust its initial hashes dictionary (and thus
     // trust new unknown values) even though the last action done was to clear
     // the hashes for path1 by setting its value to NULL (this is a regression
     // test ensuring that the internal action of clearing some hashes does
     // update the stored hash of hashes).
     PrefHashStoreImpl pref_hash_store2(
-        std::string(32, 0), "device_id", CreateHashStoreContents());
+        std::string(32, 0), "device_id", CreateHashStoreContents(), true);
     scoped_ptr<PrefHashStoreTransaction> transaction(
         pref_hash_store2.BeginTransaction());
 
     base::DictionaryValue tested_dict;
     tested_dict.Set("a", new base::StringValue("foo"));
     tested_dict.Set("b", new base::StringValue("bar"));
     EXPECT_EQ(
         PrefHashStoreTransaction::TRUSTED_UNKNOWN_VALUE,
         transaction->CheckSplitValue("new_path", &tested_dict, &invalid_keys));
     EXPECT_TRUE(invalid_keys.empty());
@@ skipping 10 matching lines @@
   base::StringValue string("string1");
 
   base::DictionaryValue dict;
   dict.Set("a", new base::StringValue("foo"));
   dict.Set("d", new base::StringValue("bad"));
   dict.Set("b", new base::StringValue("bar"));
   dict.Set("c", new base::StringValue("baz"));
 
   {
     PrefHashStoreImpl pref_hash_store(
-        std::string(32, 0), "device_id", CreateHashStoreContents());
+        std::string(32, 0), "device_id", CreateHashStoreContents(), true);
     scoped_ptr<PrefHashStoreTransaction> transaction(
         pref_hash_store.BeginTransaction());
 
     transaction->StoreHash("path1", &string);
     EXPECT_EQ(PrefHashStoreTransaction::UNCHANGED,
               transaction->CheckValue("path1", &string));
   }
 
   {
     // Load a new |pref_hash_store2| in which the hashes dictionary is trusted.
     PrefHashStoreImpl pref_hash_store2(
-        std::string(32, 0), "device_id", CreateHashStoreContents());
+        std::string(32, 0), "device_id", CreateHashStoreContents(), true);
     scoped_ptr<PrefHashStoreTransaction> transaction(
         pref_hash_store2.BeginTransaction());
     std::vector<std::string> invalid_keys;
     EXPECT_EQ(PrefHashStoreTransaction::TRUSTED_UNKNOWN_VALUE,
               transaction->CheckSplitValue("path1", &dict, &invalid_keys));
     EXPECT_TRUE(invalid_keys.empty());
   }
 }