chrome/browser/prefs/pref_hash_store_impl_unittest.cc - chromium/src.git - Git at Google

 // 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"
 #include "chrome/browser/prefs/pref_hash_store_impl.h"
 #include "chrome/browser/prefs/pref_hash_store_transaction.h"
 #include "chrome/browser/prefs/tracked/hash_store_contents.h"
 #include "testing/gtest/include/gtest/gtest.h"

 class MockHashStoreContents : public HashStoreContents {
  public:
   // Keep the data separate from the API implementation so that it can be owned
   // by the test and reused. The API implementation is owned by the
   // PrefHashStoreImpl.
   struct Data {
     Data() : commit_performed(false) {}

     // Returns the current value of |commit_performed| and resets it to false
     // immediately after.
     bool GetCommitPerformedAndReset() {
       bool current_commit_performed = commit_performed;
       commit_performed = false;
       return current_commit_performed;
     }

     scoped_ptr<base::DictionaryValue> contents;
     std::string super_mac;
     scoped_ptr<int> version;
     bool commit_performed;
   };

   explicit MockHashStoreContents(Data* data) : data_(data) {}

   // HashStoreContents implementation
   virtual std::string hash_store_id() const OVERRIDE { return "store_id"; }

   virtual void Reset() OVERRIDE {
     data_->contents.reset();
     data_->super_mac = "";
     data_->version.reset();
   }

   virtual bool IsInitialized() const OVERRIDE { return data_->contents; }

   virtual bool GetVersion(int* version) const OVERRIDE {
     if (data_->version)
       *version = *data_->version;
     return data_->version;
   }

   virtual void SetVersion(int version) OVERRIDE {
     data_->version.reset(new int(version));
   }

   virtual const base::DictionaryValue* GetContents() const OVERRIDE {
     return data_->contents.get();
   }

   virtual scoped_ptr<MutableDictionary> GetMutableContents() OVERRIDE {
     return scoped_ptr<MutableDictionary>(new MockMutableDictionary(data_));
   }

   virtual std::string GetSuperMac() const OVERRIDE { return data_->super_mac; }

   virtual void SetSuperMac(const std::string& super_mac) OVERRIDE {
     data_->super_mac = super_mac;
   }

   virtual void CommitPendingWrite() OVERRIDE {
     EXPECT_FALSE(data_->commit_performed);
     data_->commit_performed = true;
   }

  private:
   class MockMutableDictionary : public MutableDictionary {
    public:
     explicit MockMutableDictionary(Data* data) : data_(data) {}

     // MutableDictionary implementation
     virtual base::DictionaryValue* operator->() OVERRIDE {
       if (!data_->contents)
         data_->contents.reset(new base::DictionaryValue);
       return data_->contents.get();
     }

    private:
     Data* data_;
     DISALLOW_COPY_AND_ASSIGN(MockMutableDictionary);
   };

   Data* data_;

   DISALLOW_COPY_AND_ASSIGN(MockHashStoreContents);
 };

 class PrefHashStoreImplTest : public testing::Test {
  protected:
   scoped_ptr<HashStoreContents> CreateHashStoreContents() {
     return scoped_ptr<HashStoreContents>(
         new MockHashStoreContents(&hash_store_data_));
   }

   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());
     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);
     EXPECT_EQ(PrefHashStoreTransaction::UNCHANGED,
               transaction->CheckValue("path1", &string_1));
     EXPECT_EQ(PrefHashStoreTransaction::CLEARED,
               transaction->CheckValue("path1", NULL));
     transaction->StoreHash("path1", NULL);
     EXPECT_EQ(PrefHashStoreTransaction::UNCHANGED,
               transaction->CheckValue("path1", NULL));
     EXPECT_EQ(PrefHashStoreTransaction::CHANGED,
               transaction->CheckValue("path1", &string_2));

     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"));

     // Manually shove in a legacy hash.
     (*CreateHashStoreContents()->GetMutableContents())->SetString(
         "path1",
         "C503FB7C65EEFD5C07185F616A0AA67923C069909933F362022B1F187E73E9A2");

     EXPECT_EQ(PrefHashStoreTransaction::WEAK_LEGACY,
               transaction->CheckValue("path1", &dict));
     transaction->StoreHash("path1", &dict);
     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());
   }

   {
     // |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());
     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());
     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, 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());
     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);

     // Verify match post storage.
     EXPECT_EQ(PrefHashStoreTransaction::UNCHANGED,
               transaction->CheckSplitValue("path1", &dict, &invalid_keys));
     EXPECT_TRUE(invalid_keys.empty());

     // Verify new path is still unknown.
     EXPECT_EQ(PrefHashStoreTransaction::UNTRUSTED_UNKNOWN_VALUE,
               transaction->CheckSplitValue("path2", &dict, &invalid_keys));
     EXPECT_TRUE(invalid_keys.empty());

     // Verify NULL or empty dicts are declared as having been cleared.
     EXPECT_EQ(PrefHashStoreTransaction::CLEARED,
               transaction->CheckSplitValue("path1", NULL, &invalid_keys));
     EXPECT_TRUE(invalid_keys.empty());
     EXPECT_EQ(
         PrefHashStoreTransaction::CLEARED,
         transaction->CheckSplitValue("path1", &empty_dict, &invalid_keys));
     EXPECT_TRUE(invalid_keys.empty());

     // Verify changes are properly detected.
     EXPECT_EQ(
         PrefHashStoreTransaction::CHANGED,
         transaction->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");
     expected_invalid_keys1.push_back("o");
     EXPECT_EQ(expected_invalid_keys1, invalid_keys);
     invalid_keys.clear();

     // Verify |dict| still matches post check.
     EXPECT_EQ(PrefHashStoreTransaction::UNCHANGED,
               transaction->CheckSplitValue("path1", &dict, &invalid_keys));
     EXPECT_TRUE(invalid_keys.empty());

     // Store hash for |modified_dict|.
     transaction->StoreSplitHash("path1", &modified_dict);

     // Verify |modified_dict| is now the one that verifies correctly.
     EXPECT_EQ(
         PrefHashStoreTransaction::UNCHANGED,
         transaction->CheckSplitValue("path1", &modified_dict, &invalid_keys));
     EXPECT_TRUE(invalid_keys.empty());

     // Verify old dict no longer matches.
     EXPECT_EQ(PrefHashStoreTransaction::CHANGED,
               transaction->CheckSplitValue("path1", &dict, &invalid_keys));
     std::vector<std::string> expected_invalid_keys2;
     expected_invalid_keys2.push_back("a");
     expected_invalid_keys2.push_back("o");
     expected_invalid_keys2.push_back("c");
     EXPECT_EQ(expected_invalid_keys2, invalid_keys);
     invalid_keys.clear();

     // 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());
     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());
     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());
     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);
     EXPECT_EQ(PrefHashStoreTransaction::UNCHANGED,
               transaction->CheckSplitValue("path1", NULL, &invalid_keys));
     EXPECT_TRUE(invalid_keys.empty());
     EXPECT_EQ(
         PrefHashStoreTransaction::UNCHANGED,
         transaction->CheckSplitValue("path1", &empty_dict, &invalid_keys));
     EXPECT_TRUE(invalid_keys.empty());

     // Same when storing NULL directly.
     transaction->StoreSplitHash("path1", NULL);
     EXPECT_EQ(PrefHashStoreTransaction::UNCHANGED,
               transaction->CheckSplitValue("path1", NULL, &invalid_keys));
     EXPECT_TRUE(invalid_keys.empty());
     EXPECT_EQ(
         PrefHashStoreTransaction::UNCHANGED,
         transaction->CheckSplitValue("path1", &empty_dict, &invalid_keys));
     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());
     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());
   }
 }

 // Test that the PrefHashStore returns TRUSTED_UNKNOWN_VALUE when checking for
 // a split preference even if there is an existing atomic preference's hash
 // stored. There is no point providing a migration path for preferences
 // switching strategies after their initial release as split preferences are
 // turned into split preferences specifically because the atomic hash isn't
 // considered useful.
 TEST_F(PrefHashStoreImplTest, TrustedUnknownSplitValueFromExistingAtomic) {
   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());
     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());
     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());
   }
 }

 TEST_F(PrefHashStoreImplTest, GetCurrentVersion) {
   COMPILE_ASSERT(PrefHashStoreImpl::VERSION_LATEST == 2,
                  new_versions_should_be_tested_here);
   {
     PrefHashStoreImpl pref_hash_store(
         std::string(32, 0), "device_id", CreateHashStoreContents());

     // VERSION_UNINITIALIZED when no hashes are stored.
     EXPECT_EQ(PrefHashStoreImpl::VERSION_UNINITIALIZED,
               pref_hash_store.GetCurrentVersion());

     scoped_ptr<PrefHashStoreTransaction> transaction(
         pref_hash_store.BeginTransaction());
     base::StringValue string_value("foo");
     transaction->StoreHash("path1", &string_value);

     // Test that |pref_hash_store| flushes its content to disk when it
     // initializes its version.
     transaction.reset();
     pref_hash_store.CommitPendingWrite();
     EXPECT_TRUE(hash_store_data_.GetCommitPerformedAndReset());
   }
   {
     PrefHashStoreImpl pref_hash_store(
         std::string(32, 0), "device_id", CreateHashStoreContents());

     // VERSION_LATEST after storing a hash.
     EXPECT_EQ(PrefHashStoreImpl::VERSION_LATEST,
               pref_hash_store.GetCurrentVersion());

     // Test that |pref_hash_store| doesn't flush its contents to disk when it
     // didn't change.
     pref_hash_store.CommitPendingWrite();
     EXPECT_FALSE(hash_store_data_.GetCommitPerformedAndReset());
   }

   // Manually clear the version number.
   hash_store_data_.version.reset();

   {
     PrefHashStoreImpl pref_hash_store(
         std::string(32, 0), "device_id", CreateHashStoreContents());

     // VERSION_PRE_MIGRATION when no version is stored.
     EXPECT_EQ(PrefHashStoreImpl::VERSION_PRE_MIGRATION,
               pref_hash_store.GetCurrentVersion());

     scoped_ptr<PrefHashStoreTransaction> transaction(
         pref_hash_store.BeginTransaction());

     // Test that |pref_hash_store| flushes its content to disk when it
     // re-initializes its version.
     transaction.reset();
     pref_hash_store.CommitPendingWrite();
     EXPECT_TRUE(hash_store_data_.GetCommitPerformedAndReset());
   }
   {
     PrefHashStoreImpl pref_hash_store(
         std::string(32, 0), "device_id", CreateHashStoreContents());

     // Back to VERSION_LATEST after performing a transaction from
     // VERSION_PRE_MIGRATION (the presence of an existing hash should be
     // sufficient, no need for the transaction itself to perform any work).
     EXPECT_EQ(PrefHashStoreImpl::VERSION_LATEST,
               pref_hash_store.GetCurrentVersion());

     // Test that |pref_hash_store| doesn't flush its contents to disk when it
     // didn't change (i.e., its version was already up-to-date and the only
     // transaction performed was empty).
     scoped_ptr<PrefHashStoreTransaction> transaction(
         pref_hash_store.BeginTransaction());
     transaction.reset();
     pref_hash_store.CommitPendingWrite();
     EXPECT_FALSE(hash_store_data_.GetCommitPerformedAndReset());
   }
 }
	// 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"
	#include "chrome/browser/prefs/pref_hash_store_impl.h"
	#include "chrome/browser/prefs/pref_hash_store_transaction.h"
	#include "chrome/browser/prefs/tracked/hash_store_contents.h"
	#include "testing/gtest/include/gtest/gtest.h"

	class MockHashStoreContents : public HashStoreContents {
	public:
	// Keep the data separate from the API implementation so that it can be owned
	// by the test and reused. The API implementation is owned by the
	// PrefHashStoreImpl.
	struct Data {
	Data() : commit_performed(false) {}

	// Returns the current value of \|commit_performed\| and resets it to false
	// immediately after.
	bool GetCommitPerformedAndReset() {
	bool current_commit_performed = commit_performed;
	commit_performed = false;
	return current_commit_performed;
	}

	scoped_ptr<base::DictionaryValue> contents;
	std::string super_mac;
	scoped_ptr<int> version;
	bool commit_performed;
	};

	explicit MockHashStoreContents(Data* data) : data_(data) {}

	// HashStoreContents implementation
	virtual std::string hash_store_id() const OVERRIDE { return "store_id"; }

	virtual void Reset() OVERRIDE {
	data_->contents.reset();
	data_->super_mac = "";
	data_->version.reset();
	}

	virtual bool IsInitialized() const OVERRIDE { return data_->contents; }

	virtual bool GetVersion(int* version) const OVERRIDE {
	if (data_->version)
	version = data_->version;
	return data_->version;
	}

	virtual void SetVersion(int version) OVERRIDE {
	data_->version.reset(new int(version));
	}

	virtual const base::DictionaryValue* GetContents() const OVERRIDE {
	return data_->contents.get();
	}

	virtual scoped_ptr<MutableDictionary> GetMutableContents() OVERRIDE {
	return scoped_ptr<MutableDictionary>(new MockMutableDictionary(data_));
	}

	virtual std::string GetSuperMac() const OVERRIDE { return data_->super_mac; }

	virtual void SetSuperMac(const std::string& super_mac) OVERRIDE {
	data_->super_mac = super_mac;
	}

	virtual void CommitPendingWrite() OVERRIDE {
	EXPECT_FALSE(data_->commit_performed);
	data_->commit_performed = true;
	}

	private:
	class MockMutableDictionary : public MutableDictionary {
	public:
	explicit MockMutableDictionary(Data* data) : data_(data) {}

	// MutableDictionary implementation
	virtual base::DictionaryValue* operator->() OVERRIDE {
	if (!data_->contents)
	data_->contents.reset(new base::DictionaryValue);
	return data_->contents.get();
	}

	private:
	Data* data_;
	DISALLOW_COPY_AND_ASSIGN(MockMutableDictionary);
	};

	Data* data_;

	DISALLOW_COPY_AND_ASSIGN(MockHashStoreContents);
	};

	class PrefHashStoreImplTest : public testing::Test {
	protected:
	scoped_ptr<HashStoreContents> CreateHashStoreContents() {
	return scoped_ptr<HashStoreContents>(
	new MockHashStoreContents(&hash_store_data_));
	}

	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());
	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);
	EXPECT_EQ(PrefHashStoreTransaction::UNCHANGED,
	transaction->CheckValue("path1", &string_1));
	EXPECT_EQ(PrefHashStoreTransaction::CLEARED,
	transaction->CheckValue("path1", NULL));
	transaction->StoreHash("path1", NULL);
	EXPECT_EQ(PrefHashStoreTransaction::UNCHANGED,
	transaction->CheckValue("path1", NULL));
	EXPECT_EQ(PrefHashStoreTransaction::CHANGED,
	transaction->CheckValue("path1", &string_2));

	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"));

	// Manually shove in a legacy hash.
	(*CreateHashStoreContents()->GetMutableContents())->SetString(
	"path1",
	"C503FB7C65EEFD5C07185F616A0AA67923C069909933F362022B1F187E73E9A2");

	EXPECT_EQ(PrefHashStoreTransaction::WEAK_LEGACY,
	transaction->CheckValue("path1", &dict));
	transaction->StoreHash("path1", &dict);
	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());
	}

	{
	// \|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());
	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());
	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, 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());
	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);

	// Verify match post storage.
	EXPECT_EQ(PrefHashStoreTransaction::UNCHANGED,
	transaction->CheckSplitValue("path1", &dict, &invalid_keys));
	EXPECT_TRUE(invalid_keys.empty());

	// Verify new path is still unknown.
	EXPECT_EQ(PrefHashStoreTransaction::UNTRUSTED_UNKNOWN_VALUE,
	transaction->CheckSplitValue("path2", &dict, &invalid_keys));
	EXPECT_TRUE(invalid_keys.empty());

	// Verify NULL or empty dicts are declared as having been cleared.
	EXPECT_EQ(PrefHashStoreTransaction::CLEARED,
	transaction->CheckSplitValue("path1", NULL, &invalid_keys));
	EXPECT_TRUE(invalid_keys.empty());
	EXPECT_EQ(
	PrefHashStoreTransaction::CLEARED,
	transaction->CheckSplitValue("path1", &empty_dict, &invalid_keys));
	EXPECT_TRUE(invalid_keys.empty());

	// Verify changes are properly detected.
	EXPECT_EQ(
	PrefHashStoreTransaction::CHANGED,
	transaction->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");
	expected_invalid_keys1.push_back("o");
	EXPECT_EQ(expected_invalid_keys1, invalid_keys);
	invalid_keys.clear();

	// Verify \|dict\| still matches post check.
	EXPECT_EQ(PrefHashStoreTransaction::UNCHANGED,
	transaction->CheckSplitValue("path1", &dict, &invalid_keys));
	EXPECT_TRUE(invalid_keys.empty());

	// Store hash for \|modified_dict\|.
	transaction->StoreSplitHash("path1", &modified_dict);

	// Verify \|modified_dict\| is now the one that verifies correctly.
	EXPECT_EQ(
	PrefHashStoreTransaction::UNCHANGED,
	transaction->CheckSplitValue("path1", &modified_dict, &invalid_keys));
	EXPECT_TRUE(invalid_keys.empty());

	// Verify old dict no longer matches.
	EXPECT_EQ(PrefHashStoreTransaction::CHANGED,
	transaction->CheckSplitValue("path1", &dict, &invalid_keys));
	std::vector<std::string> expected_invalid_keys2;
	expected_invalid_keys2.push_back("a");
	expected_invalid_keys2.push_back("o");
	expected_invalid_keys2.push_back("c");
	EXPECT_EQ(expected_invalid_keys2, invalid_keys);
	invalid_keys.clear();

	// 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());
	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());
	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());
	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);
	EXPECT_EQ(PrefHashStoreTransaction::UNCHANGED,
	transaction->CheckSplitValue("path1", NULL, &invalid_keys));
	EXPECT_TRUE(invalid_keys.empty());
	EXPECT_EQ(
	PrefHashStoreTransaction::UNCHANGED,
	transaction->CheckSplitValue("path1", &empty_dict, &invalid_keys));
	EXPECT_TRUE(invalid_keys.empty());

	// Same when storing NULL directly.
	transaction->StoreSplitHash("path1", NULL);
	EXPECT_EQ(PrefHashStoreTransaction::UNCHANGED,
	transaction->CheckSplitValue("path1", NULL, &invalid_keys));
	EXPECT_TRUE(invalid_keys.empty());
	EXPECT_EQ(
	PrefHashStoreTransaction::UNCHANGED,
	transaction->CheckSplitValue("path1", &empty_dict, &invalid_keys));
	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());
	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());
	}
	}

	// Test that the PrefHashStore returns TRUSTED_UNKNOWN_VALUE when checking for
	// a split preference even if there is an existing atomic preference's hash
	// stored. There is no point providing a migration path for preferences
	// switching strategies after their initial release as split preferences are
	// turned into split preferences specifically because the atomic hash isn't
	// considered useful.
	TEST_F(PrefHashStoreImplTest, TrustedUnknownSplitValueFromExistingAtomic) {
	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());
	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());
	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());
	}
	}

	TEST_F(PrefHashStoreImplTest, GetCurrentVersion) {
	COMPILE_ASSERT(PrefHashStoreImpl::VERSION_LATEST == 2,
	new_versions_should_be_tested_here);
	{
	PrefHashStoreImpl pref_hash_store(
	std::string(32, 0), "device_id", CreateHashStoreContents());

	// VERSION_UNINITIALIZED when no hashes are stored.
	EXPECT_EQ(PrefHashStoreImpl::VERSION_UNINITIALIZED,
	pref_hash_store.GetCurrentVersion());

	scoped_ptr<PrefHashStoreTransaction> transaction(
	pref_hash_store.BeginTransaction());
	base::StringValue string_value("foo");
	transaction->StoreHash("path1", &string_value);

	// Test that \|pref_hash_store\| flushes its content to disk when it
	// initializes its version.
	transaction.reset();
	pref_hash_store.CommitPendingWrite();
	EXPECT_TRUE(hash_store_data_.GetCommitPerformedAndReset());
	}
	{
	PrefHashStoreImpl pref_hash_store(
	std::string(32, 0), "device_id", CreateHashStoreContents());

	// VERSION_LATEST after storing a hash.
	EXPECT_EQ(PrefHashStoreImpl::VERSION_LATEST,
	pref_hash_store.GetCurrentVersion());

	// Test that \|pref_hash_store\| doesn't flush its contents to disk when it
	// didn't change.
	pref_hash_store.CommitPendingWrite();
	EXPECT_FALSE(hash_store_data_.GetCommitPerformedAndReset());
	}

	// Manually clear the version number.
	hash_store_data_.version.reset();

	{
	PrefHashStoreImpl pref_hash_store(
	std::string(32, 0), "device_id", CreateHashStoreContents());

	// VERSION_PRE_MIGRATION when no version is stored.
	EXPECT_EQ(PrefHashStoreImpl::VERSION_PRE_MIGRATION,
	pref_hash_store.GetCurrentVersion());

	scoped_ptr<PrefHashStoreTransaction> transaction(
	pref_hash_store.BeginTransaction());

	// Test that \|pref_hash_store\| flushes its content to disk when it
	// re-initializes its version.
	transaction.reset();
	pref_hash_store.CommitPendingWrite();
	EXPECT_TRUE(hash_store_data_.GetCommitPerformedAndReset());
	}
	{
	PrefHashStoreImpl pref_hash_store(
	std::string(32, 0), "device_id", CreateHashStoreContents());

	// Back to VERSION_LATEST after performing a transaction from
	// VERSION_PRE_MIGRATION (the presence of an existing hash should be
	// sufficient, no need for the transaction itself to perform any work).
	EXPECT_EQ(PrefHashStoreImpl::VERSION_LATEST,
	pref_hash_store.GetCurrentVersion());

	// Test that \|pref_hash_store\| doesn't flush its contents to disk when it
	// didn't change (i.e., its version was already up-to-date and the only
	// transaction performed was empty).
	scoped_ptr<PrefHashStoreTransaction> transaction(
	pref_hash_store.BeginTransaction());
	transaction.reset();
	pref_hash_store.CommitPendingWrite();
	EXPECT_FALSE(hash_store_data_.GetCommitPerformedAndReset());
	}
	}