From 7324afb043a0b1e623d8e8eb906cdc53bdeb4685 Mon Sep 17 00:00:00 2001 From: Allan Sandfeld Jensen Date: Wed, 5 Apr 2017 17:15:33 +0200 Subject: BASELINE: Update Chromium to 58.0.3029.54 Change-Id: I67f57065a7afdc8e4614adb5c0230281428df4d1 Reviewed-by: Peter Varga --- .../user_prefs/tracked/pref_hash_calculator.cc | 21 ++------ .../user_prefs/tracked/pref_hash_calculator.h | 11 ++-- .../tracked/pref_hash_calculator_unittest.cc | 62 ++++++++++------------ .../tracked/pref_hash_filter_unittest.cc | 30 +++++------ .../user_prefs/tracked/pref_hash_store_impl.cc | 36 +++++++++++-- .../user_prefs/tracked/pref_hash_store_impl.h | 6 +-- .../registry_hash_store_contents_win_unittest.cc | 3 +- .../user_prefs/tracked/segregated_pref_store.cc | 14 +++++ .../user_prefs/tracked/segregated_pref_store.h | 1 + .../tracked/segregated_pref_store_unittest.cc | 30 +++++++++++ 10 files changed, 134 insertions(+), 80 deletions(-) (limited to 'chromium/components/user_prefs') diff --git a/chromium/components/user_prefs/tracked/pref_hash_calculator.cc b/chromium/components/user_prefs/tracked/pref_hash_calculator.cc index 12fb03d8fe8..8d73c1dcbc9 100644 --- a/chromium/components/user_prefs/tracked/pref_hash_calculator.cc +++ b/chromium/components/user_prefs/tracked/pref_hash_calculator.cc @@ -79,27 +79,12 @@ std::string GetMessage(const std::string& device_id, return message; } -// Generates a device ID based on the input device ID. The derived device ID has -// no useful properties beyond those of the input device ID except that it is -// consistent with previous implementations. -// TODO(gab): Remove this once UMA reports for -// Settings.TrackedPreferenceMigratedLegacyDeviceId become insignificant. -std::string GenerateDeviceIdLikePrefMetricsServiceDid( - const std::string& original_device_id) { - if (original_device_id.empty()) - return std::string(); - return base::ToLowerASCII( - GetDigestString(original_device_id, "PrefMetricsService")); -} - } // namespace PrefHashCalculator::PrefHashCalculator(const std::string& seed, - const std::string& device_id) - : seed_(seed), - device_id_(device_id), - legacy_device_id_(GenerateDeviceIdLikePrefMetricsServiceDid(device_id)) { -} + const std::string& device_id, + const std::string& legacy_device_id) + : seed_(seed), device_id_(device_id), legacy_device_id_(legacy_device_id) {} PrefHashCalculator::~PrefHashCalculator() { } diff --git a/chromium/components/user_prefs/tracked/pref_hash_calculator.h b/chromium/components/user_prefs/tracked/pref_hash_calculator.h index 1f9b74f0ad7..92b0c3a05d9 100644 --- a/chromium/components/user_prefs/tracked/pref_hash_calculator.h +++ b/chromium/components/user_prefs/tracked/pref_hash_calculator.h @@ -23,10 +23,13 @@ class PrefHashCalculator { VALID_SECURE_LEGACY, }; - // Constructs a PrefHashCalculator using |seed| and |device_id|. The same - // parameters must be used in order to successfully validate generated hashes. - // |device_id| may be empty. - PrefHashCalculator(const std::string& seed, const std::string& device_id); + // Constructs a PrefHashCalculator using |seed|, |device_id| and + // |legacy_device_id|. The same parameters must be used in order to + // successfully validate generated hashes. |_device_id| or |legacy_device_id| + // may be empty. + PrefHashCalculator(const std::string& seed, + const std::string& device_id, + const std::string& legacy_device_id); ~PrefHashCalculator(); diff --git a/chromium/components/user_prefs/tracked/pref_hash_calculator_unittest.cc b/chromium/components/user_prefs/tracked/pref_hash_calculator_unittest.cc index 4d29146ada9..11e38f1d76d 100644 --- a/chromium/components/user_prefs/tracked/pref_hash_calculator_unittest.cc +++ b/chromium/components/user_prefs/tracked/pref_hash_calculator_unittest.cc @@ -24,10 +24,10 @@ TEST(PrefHashCalculatorTest, TestCurrentAlgorithm) { 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"); + PrefHashCalculator calc1("seed1", "deviceid", "legacydeviceid"); + PrefHashCalculator calc1_dup("seed1", "deviceid", "legacydeviceid"); + PrefHashCalculator calc2("seed2", "deviceid", "legacydeviceid"); + PrefHashCalculator calc3("seed1", "deviceid2", "legacydeviceid"); // Two calculators with same seed produce same hash. ASSERT_EQ(calc1.Calculate("pref_path", &string_value_1), @@ -77,11 +77,9 @@ TEST(PrefHashCalculatorTest, CatchHashChanges) { static const char kDeviceId[] = "test_device_id1"; std::unique_ptr null_value = base::Value::CreateNullValue(); - std::unique_ptr bool_value(new base::FundamentalValue(false)); - std::unique_ptr int_value( - new base::FundamentalValue(1234567890)); - std::unique_ptr double_value( - new base::FundamentalValue(123.0987654321)); + std::unique_ptr bool_value(new base::Value(false)); + std::unique_ptr int_value(new base::Value(1234567890)); + std::unique_ptr double_value(new base::Value(123.0987654321)); std::unique_ptr string_value( new base::StringValue("testing with special chars:\n<>{}:^^@#$\\/")); @@ -124,46 +122,46 @@ TEST(PrefHashCalculatorTest, CatchHashChanges) { static const char kExpectedNullValue[] = "82A9F3BBC7F9FF84C76B033C854E79EEB162783FA7B3E99FF9372FA8E12C44F7"; EXPECT_EQ(PrefHashCalculator::VALID, - PrefHashCalculator(kSeed, kDeviceId) + PrefHashCalculator(kSeed, kDeviceId, "legacydeviceid") .Validate("pref.path", null_value.get(), kExpectedNullValue)); static const char kExpectedBooleanValue[] = "A520D8F43EA307B0063736DC9358C330539D0A29417580514C8B9862632C4CCC"; EXPECT_EQ( PrefHashCalculator::VALID, - PrefHashCalculator(kSeed, kDeviceId) + PrefHashCalculator(kSeed, kDeviceId, "legacydeviceid") .Validate("pref.path", bool_value.get(), kExpectedBooleanValue)); static const char kExpectedIntegerValue[] = "8D60DA1F10BF5AA29819D2D66D7CCEF9AABC5DA93C11A0D2BD21078D63D83682"; EXPECT_EQ(PrefHashCalculator::VALID, - PrefHashCalculator(kSeed, kDeviceId) + PrefHashCalculator(kSeed, kDeviceId, "legacydeviceid") .Validate("pref.path", int_value.get(), kExpectedIntegerValue)); static const char kExpectedDoubleValue[] = "C9D94772516125BEEDAE68C109D44BC529E719EE020614E894CC7FB4098C545D"; EXPECT_EQ( PrefHashCalculator::VALID, - PrefHashCalculator(kSeed, kDeviceId) + PrefHashCalculator(kSeed, kDeviceId, "legacydeviceid") .Validate("pref.path", double_value.get(), kExpectedDoubleValue)); static const char kExpectedStringValue[] = "05ACCBD3B05C45C36CD06190F63EC577112311929D8380E26E5F13182EB68318"; EXPECT_EQ( PrefHashCalculator::VALID, - PrefHashCalculator(kSeed, kDeviceId) + PrefHashCalculator(kSeed, kDeviceId, "legacydeviceid") .Validate("pref.path", string_value.get(), kExpectedStringValue)); static const char kExpectedDictValue[] = "7A84DCC710D796C771F789A4DA82C952095AA956B6F1667EE42D0A19ECAA3C4A"; EXPECT_EQ(PrefHashCalculator::VALID, - PrefHashCalculator(kSeed, kDeviceId) + PrefHashCalculator(kSeed, kDeviceId, "legacydeviceid") .Validate("pref.path", dict_value.get(), kExpectedDictValue)); static const char kExpectedListValue[] = "8D5A25972DF5AE20D041C780E7CA54E40F614AD53513A0724EE8D62D4F992740"; EXPECT_EQ(PrefHashCalculator::VALID, - PrefHashCalculator(kSeed, kDeviceId) + PrefHashCalculator(kSeed, kDeviceId, "legacydeviceid") .Validate("pref.path", list_value.get(), kExpectedListValue)); // Also test every value type together in the same dictionary. @@ -178,28 +176,22 @@ TEST(PrefHashCalculatorTest, CatchHashChanges) { static const char kExpectedEverythingValue[] = "B97D09BE7005693574DCBDD03D8D9E44FB51F4008B73FB56A49A9FA671A1999B"; EXPECT_EQ(PrefHashCalculator::VALID, - PrefHashCalculator(kSeed, kDeviceId) + PrefHashCalculator(kSeed, kDeviceId, "legacydeviceid") .Validate("pref.path", &everything, kExpectedEverythingValue)); } -TEST(PrefHashCalculatorTest, TestCompatibilityWithLegacyPrefMetricsServiceId) { - static const char kSeed[] = { - 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0A, - 0x0B, 0x0C, 0x0D, 0x0E, 0x0F, 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, - 0x06, 0x07, 0x08, 0x09, 0x0A, 0x0B, 0x0C, 0x0D, 0x0E, 0x0F, 0x00, - 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0A, 0x0B, - 0x0C, 0x0D, 0x0E, 0x0F, 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, - 0x07, 0x08, 0x09, 0x0A, 0x0B, 0x0C, 0x0D, 0x0E, 0x0F}; - static const char kDeviceId[] = - "D730D9CBD98C734A4FB097A1922275FE9F7E026A4EA1BE0E84"; - static const char kExpectedValue[] = - "845EF34663FF8D32BE6707F40258FBA531C2BFC532E3B014AFB3476115C2A9DE"; +TEST(PrefHashCalculatorTest, TestCompatibilityWithLegacyDeviceId) { + static const char kSeed[] = "0123456789ABCDEF0123456789ABCDEF"; + static const char kNewDeviceId[] = "new_test_device_id1"; + static const char kLegacyDeviceId[] = "test_device_id1"; - base::ListValue startup_urls; - startup_urls.Set(0, new base::StringValue("http://www.chromium.org/")); + // As in PrefHashCalculatorTest.CatchHashChanges. + const base::StringValue string_value( + "testing with special chars:\n<>{}:^^@#$\\/"); + static const char kExpectedValue[] = + "05ACCBD3B05C45C36CD06190F63EC577112311929D8380E26E5F13182EB68318"; - EXPECT_EQ( - PrefHashCalculator::VALID_SECURE_LEGACY, - PrefHashCalculator(std::string(kSeed, arraysize(kSeed)), kDeviceId) - .Validate("session.startup_urls", &startup_urls, kExpectedValue)); + EXPECT_EQ(PrefHashCalculator::VALID_SECURE_LEGACY, + PrefHashCalculator(kSeed, kNewDeviceId, kLegacyDeviceId) + .Validate("pref.path", &string_value, kExpectedValue)); } diff --git a/chromium/components/user_prefs/tracked/pref_hash_filter_unittest.cc b/chromium/components/user_prefs/tracked/pref_hash_filter_unittest.cc index 1d3afd4b9fc..42ea4f5092a 100644 --- a/chromium/components/user_prefs/tracked/pref_hash_filter_unittest.cc +++ b/chromium/components/user_prefs/tracked/pref_hash_filter_unittest.cc @@ -802,12 +802,12 @@ TEST_P(PrefHashFilterTest, FilterUntrackedPrefUpdate) { TEST_P(PrefHashFilterTest, MultiplePrefsFilterSerializeData) { base::DictionaryValue root_dict; // Ownership of the following values is transfered to |root_dict|. - base::Value* int_value1 = new base::FundamentalValue(1); - base::Value* int_value2 = new base::FundamentalValue(2); - base::Value* int_value3 = new base::FundamentalValue(3); - base::Value* int_value4 = new base::FundamentalValue(4); + base::Value* int_value1 = new base::Value(1); + base::Value* int_value2 = new base::Value(2); + base::Value* int_value3 = new base::Value(3); + base::Value* int_value4 = new base::Value(4); base::DictionaryValue* dict_value = new base::DictionaryValue; - dict_value->Set("a", new base::FundamentalValue(true)); + dict_value->Set("a", new base::Value(true)); root_dict.Set(kAtomicPref, int_value1); root_dict.Set(kAtomicPref2, int_value2); root_dict.Set(kAtomicPref3, int_value3); @@ -821,7 +821,7 @@ TEST_P(PrefHashFilterTest, MultiplePrefsFilterSerializeData) { ASSERT_EQ(0u, mock_pref_hash_store_->stored_paths_count()); // Update kAtomicPref3 again, nothing should be stored still. - base::Value* int_value5 = new base::FundamentalValue(5); + base::Value* int_value5 = new base::Value(5); root_dict.Set(kAtomicPref3, int_value5); ASSERT_EQ(0u, mock_pref_hash_store_->stored_paths_count()); @@ -1014,7 +1014,7 @@ TEST_P(PrefHashFilterTest, InitialValueTrustedUnknown) { TEST_P(PrefHashFilterTest, InitialValueChanged) { // Ownership of this value is transfered to |pref_store_contents_|. - base::Value* int_value = new base::FundamentalValue(1234); + base::Value* int_value = new base::Value(1234); pref_store_contents_->Set(kAtomicPref, int_value); base::DictionaryValue* dict_value = new base::DictionaryValue; @@ -1187,9 +1187,9 @@ TEST_P(PrefHashFilterTest, InitialValueUnchangedLegacyId) { TEST_P(PrefHashFilterTest, DontResetReportOnly) { // Ownership of these values is transfered to |pref_store_contents_|. - base::Value* int_value1 = new base::FundamentalValue(1); - base::Value* int_value2 = new base::FundamentalValue(2); - base::Value* report_only_val = new base::FundamentalValue(3); + base::Value* int_value1 = new base::Value(1); + base::Value* int_value2 = new base::Value(2); + base::Value* report_only_val = new base::Value(3); base::DictionaryValue* report_only_split_val = new base::DictionaryValue; report_only_split_val->SetInteger("a", 1234); pref_store_contents_->Set(kAtomicPref, int_value1); @@ -1264,10 +1264,10 @@ TEST_P(PrefHashFilterTest, DontResetReportOnly) { TEST_P(PrefHashFilterTest, CallFilterSerializeDataCallbacks) { base::DictionaryValue root_dict; // Ownership of the following values is transfered to |root_dict|. - base::Value* int_value1 = new base::FundamentalValue(1); - base::Value* int_value2 = new base::FundamentalValue(2); + base::Value* int_value1 = new base::Value(1); + base::Value* int_value2 = new base::Value(2); base::DictionaryValue* dict_value = new base::DictionaryValue; - dict_value->Set("a", new base::FundamentalValue(true)); + dict_value->Set("a", new base::Value(true)); root_dict.Set(kAtomicPref, int_value1); root_dict.Set(kAtomicPref2, int_value2); root_dict.Set(kSplitPref, dict_value); @@ -1313,7 +1313,7 @@ TEST_P(PrefHashFilterTest, CallFilterSerializeDataCallbacks) { TEST_P(PrefHashFilterTest, CallFilterSerializeDataCallbacksWithFailure) { base::DictionaryValue root_dict; // Ownership of the following values is transfered to |root_dict|. - base::Value* int_value1 = new base::FundamentalValue(1); + base::Value* int_value1 = new base::Value(1); root_dict.Set(kAtomicPref, int_value1); // Only update kAtomicPref. @@ -1341,7 +1341,7 @@ TEST_P(PrefHashFilterTest, CallFilterSerializeDataCallbacksWithFailure) { TEST_P(PrefHashFilterTest, ExternalValidationValueChanged) { // Ownership of this value is transfered to |pref_store_contents_|. - base::Value* int_value = new base::FundamentalValue(1234); + base::Value* int_value = new base::Value(1234); pref_store_contents_->Set(kAtomicPref, int_value); base::DictionaryValue* dict_value = new base::DictionaryValue; diff --git a/chromium/components/user_prefs/tracked/pref_hash_store_impl.cc b/chromium/components/user_prefs/tracked/pref_hash_store_impl.cc index 80438d6954a..bb920ca4c98 100644 --- a/chromium/components/user_prefs/tracked/pref_hash_store_impl.cc +++ b/chromium/components/user_prefs/tracked/pref_hash_store_impl.cc @@ -9,9 +9,37 @@ #include "base/logging.h" #include "base/macros.h" -#include "base/metrics/histogram.h" +#include "base/metrics/histogram_macros.h" +#include "components/user_prefs/tracked/device_id.h" #include "components/user_prefs/tracked/hash_store_contents.h" +namespace { + +// Returns a deterministic ID for this machine. +std::string GenerateDeviceId() { + static std::string cached_device_id; + if (!cached_device_id.empty()) + return cached_device_id; + + std::string device_id; + MachineIdStatus status = GetDeterministicMachineSpecificId(&device_id); + if (status != MachineIdStatus::NOT_IMPLEMENTED) { + // TODO(proberge): Remove this histogram once we validate that machine id + // generation is not flaky and consider adding a CHECK or DCHECK. + UMA_HISTOGRAM_BOOLEAN("Settings.MachineIdGenerationSuccess", + status == MachineIdStatus::SUCCESS); + } + + if (status == MachineIdStatus::SUCCESS) { + cached_device_id = device_id; + return device_id; + } + + return std::string(); +} + +} // namespace + class PrefHashStoreImpl::PrefHashStoreTransactionImpl : public PrefHashStoreTransaction { public: @@ -49,10 +77,10 @@ class PrefHashStoreImpl::PrefHashStoreTransactionImpl }; PrefHashStoreImpl::PrefHashStoreImpl(const std::string& seed, - const std::string& device_id, + const std::string& legacy_device_id, bool use_super_mac) - : pref_hash_calculator_(seed, device_id), use_super_mac_(use_super_mac) { -} + : pref_hash_calculator_(seed, GenerateDeviceId(), legacy_device_id), + use_super_mac_(use_super_mac) {} PrefHashStoreImpl::~PrefHashStoreImpl() { } diff --git a/chromium/components/user_prefs/tracked/pref_hash_store_impl.h b/chromium/components/user_prefs/tracked/pref_hash_store_impl.h index 1b5682eed4e..76b6f7597e1 100644 --- a/chromium/components/user_prefs/tracked/pref_hash_store_impl.h +++ b/chromium/components/user_prefs/tracked/pref_hash_store_impl.h @@ -25,12 +25,12 @@ class PrefHashStoreImpl : public PrefHashStore { }; // Constructs a PrefHashStoreImpl that calculates hashes using - // |seed| and |device_id| and stores them in |contents|. + // |seed| and |legacy_device_id| and stores them in |contents|. // - // The same |seed| and |device_id| must be used to load and validate + // The same |seed| and |legacy_device_id| must be used to load and validate // previously stored hashes in |contents|. PrefHashStoreImpl(const std::string& seed, - const std::string& device_id, + const std::string& legacy_device_id, bool use_super_mac); ~PrefHashStoreImpl() override; diff --git a/chromium/components/user_prefs/tracked/registry_hash_store_contents_win_unittest.cc b/chromium/components/user_prefs/tracked/registry_hash_store_contents_win_unittest.cc index a34d7ade788..8b53b920da3 100644 --- a/chromium/components/user_prefs/tracked/registry_hash_store_contents_win_unittest.cc +++ b/chromium/components/user_prefs/tracked/registry_hash_store_contents_win_unittest.cc @@ -30,7 +30,8 @@ class RegistryHashStoreContentsWinTest : public testing::Test { RegistryHashStoreContentsWinTest() {} void SetUp() override { - registry_override_manager_.OverrideRegistry(HKEY_CURRENT_USER); + ASSERT_NO_FATAL_FAILURE( + registry_override_manager_.OverrideRegistry(HKEY_CURRENT_USER)); contents.reset(new RegistryHashStoreContentsWin(kRegistryPath, kStoreKey)); } diff --git a/chromium/components/user_prefs/tracked/segregated_pref_store.cc b/chromium/components/user_prefs/tracked/segregated_pref_store.cc index edb1f205992..297e2a7e58f 100644 --- a/chromium/components/user_prefs/tracked/segregated_pref_store.cc +++ b/chromium/components/user_prefs/tracked/segregated_pref_store.cc @@ -83,6 +83,20 @@ bool SegregatedPrefStore::GetValue(const std::string& key, return StoreForKey(key)->GetValue(key, result); } +std::unique_ptr SegregatedPrefStore::GetValues() const { + auto values = default_pref_store_->GetValues(); + auto selected_pref_store_values = selected_pref_store_->GetValues(); + for (const auto& key : selected_preference_names_) { + const base::Value* value = nullptr; + if (selected_pref_store_values->Get(key, &value)) { + values->Set(key, value->CreateDeepCopy()); + } else { + values->Remove(key, nullptr); + } + } + return values; +} + void SegregatedPrefStore::SetValue(const std::string& key, std::unique_ptr value, uint32_t flags) { diff --git a/chromium/components/user_prefs/tracked/segregated_pref_store.h b/chromium/components/user_prefs/tracked/segregated_pref_store.h index 016cca6d049..40629768f01 100644 --- a/chromium/components/user_prefs/tracked/segregated_pref_store.h +++ b/chromium/components/user_prefs/tracked/segregated_pref_store.h @@ -52,6 +52,7 @@ class SegregatedPrefStore : public PersistentPrefStore { bool IsInitializationComplete() const override; bool GetValue(const std::string& key, const base::Value** result) const override; + std::unique_ptr GetValues() const override; // WriteablePrefStore implementation void SetValue(const std::string& key, diff --git a/chromium/components/user_prefs/tracked/segregated_pref_store_unittest.cc b/chromium/components/user_prefs/tracked/segregated_pref_store_unittest.cc index 5d32d027d5e..a4b40b15778 100644 --- a/chromium/components/user_prefs/tracked/segregated_pref_store_unittest.cc +++ b/chromium/components/user_prefs/tracked/segregated_pref_store_unittest.cc @@ -24,6 +24,7 @@ namespace { const char kSelectedPref[] = "selected_pref"; const char kUnselectedPref[] = "unselected_pref"; +const char kSharedPref[] = "shared_pref"; const char kValue1[] = "value1"; const char kValue2[] = "value2"; @@ -70,6 +71,7 @@ class SegregatedPrefStoreTest : public testing::Test { std::set selected_pref_names; selected_pref_names.insert(kSelectedPref); + selected_pref_names.insert(kSharedPref); segregated_store_ = new SegregatedPrefStore(default_store_, selected_store_, selected_pref_names); @@ -274,3 +276,31 @@ TEST_F(SegregatedPrefStoreTest, IsInitializationCompleteAsync) { default_store_->SetBlockAsyncRead(false); EXPECT_TRUE(segregated_store_->IsInitializationComplete()); } + +TEST_F(SegregatedPrefStoreTest, GetValues) { + // To check merge behavior, create selected and default stores so each has a + // key the other doesn't have and they have one key in common. + selected_store_->SetValue(kSelectedPref, + base::MakeUnique(kValue1), + WriteablePrefStore::DEFAULT_PREF_WRITE_FLAGS); + default_store_->SetValue(kUnselectedPref, + base::MakeUnique(kValue2), + WriteablePrefStore::DEFAULT_PREF_WRITE_FLAGS); + selected_store_->SetValue(kSharedPref, + base::MakeUnique(kValue1), + WriteablePrefStore::DEFAULT_PREF_WRITE_FLAGS); + + auto values = segregated_store_->GetValues(); + const base::Value* value = nullptr; + // Check that a selected preference is returned. + ASSERT_TRUE(values->Get(kSelectedPref, &value)); + EXPECT_TRUE(base::Value(kValue1).Equals(value)); + + // Check that a a default preference is returned. + ASSERT_TRUE(values->Get(kUnselectedPref, &value)); + EXPECT_TRUE(base::Value(kValue2).Equals(value)); + + // Check that the selected preference is preferred. + ASSERT_TRUE(values->Get(kSharedPref, &value)); + EXPECT_TRUE(base::Value(kValue1).Equals(value)); +} -- cgit v1.2.1