-// Copyright (c) 2012 The Chromium Authors. All rights reserved.
+// Copyright 2012 The Chromium Authors
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
#include <string>
-#include "base/macros.h"
+#include "base/functional/callback_helpers.h"
#include "base/time/time.h"
#include "base/values.h"
#include "components/prefs/json_pref_store.h"
#include "components/prefs/mock_pref_change_callback.h"
#include "components/prefs/pref_change_registrar.h"
+#include "components/prefs/pref_notifier_impl.h"
#include "components/prefs/pref_registry_simple.h"
#include "components/prefs/pref_service_factory.h"
#include "components/prefs/pref_value_store.h"
using testing::_;
using testing::Mock;
+namespace {
+
const char kPrefName[] = "pref.name";
+const char kStandaloneBrowserPref[] = "standalone_browser_pref";
+
+} // namespace
TEST(PrefServiceTest, NoObserverFire) {
TestingPrefServiceSimple prefs;
const char pref_name[] = "homepage";
TestingPrefServiceSimple prefs;
- prefs.SetUserPref(pref_name,
- std::make_unique<base::Value>("http://www.cnn.com"));
+ prefs.SetUserPref(pref_name, base::Value("http://www.cnn.com"));
prefs.registry()->RegisterStringPref(pref_name, std::string());
const char new_pref_value[] = "http://www.google.com/";
obs2.Expect(pref_name, &expected_new_pref_value2);
// This should fire the checks in obs and obs2 but with an unchanged value
// as the recommended value is being overridden by the user-set value.
- prefs.SetRecommendedPref(pref_name, recommended_pref_value.CreateDeepCopy());
+ prefs.SetRecommendedPref(pref_name, recommended_pref_value.Clone());
Mock::VerifyAndClearExpectations(&obs);
Mock::VerifyAndClearExpectations(&obs2);
prefs.registry()->RegisterIntegerPref(kPrefName, kTestValue);
// Check falling back to a recommended value.
- prefs.SetUserPref(kPrefName, std::make_unique<base::Value>("not an integer"));
+ prefs.SetUserPref(kPrefName, base::Value("not an integer"));
const PrefService::Preference* pref = prefs.FindPreference(kPrefName);
ASSERT_TRUE(pref);
const base::Value* value = pref->GetValue();
ASSERT_TRUE(value);
EXPECT_EQ(base::Value::Type::INTEGER, value->type());
- int actual_int_value = -1;
- EXPECT_TRUE(value->GetAsInteger(&actual_int_value));
- EXPECT_EQ(kTestValue, actual_int_value);
+ ASSERT_TRUE(value->is_int());
+ EXPECT_EQ(kTestValue, value->GetInt());
}
TEST(PrefServiceTest, GetValueAndGetRecommendedValue) {
const base::Value* value = pref->GetValue();
ASSERT_TRUE(value);
EXPECT_EQ(base::Value::Type::INTEGER, value->type());
- int actual_int_value = -1;
- EXPECT_TRUE(value->GetAsInteger(&actual_int_value));
- EXPECT_EQ(kDefaultValue, actual_int_value);
+ ASSERT_TRUE(value->is_int());
+ EXPECT_EQ(kDefaultValue, value->GetInt());
// Check that GetRecommendedValue() returns no value.
value = pref->GetRecommendedValue();
ASSERT_FALSE(value);
// Set a user-set value.
- prefs.SetUserPref(kPrefName, std::make_unique<base::Value>(kUserValue));
+ prefs.SetUserPref(kPrefName, base::Value(kUserValue));
// Check that GetValue() returns the user-set value.
value = pref->GetValue();
ASSERT_TRUE(value);
EXPECT_EQ(base::Value::Type::INTEGER, value->type());
- actual_int_value = -1;
- EXPECT_TRUE(value->GetAsInteger(&actual_int_value));
- EXPECT_EQ(kUserValue, actual_int_value);
+ ASSERT_TRUE(value->is_int());
+ EXPECT_EQ(kUserValue, value->GetInt());
// Check that GetRecommendedValue() returns no value.
value = pref->GetRecommendedValue();
ASSERT_FALSE(value);
// Set a recommended value.
- prefs.SetRecommendedPref(kPrefName,
- std::make_unique<base::Value>(kRecommendedValue));
+ prefs.SetRecommendedPref(kPrefName, base::Value(kRecommendedValue));
// Check that GetValue() returns the user-set value.
value = pref->GetValue();
ASSERT_TRUE(value);
EXPECT_EQ(base::Value::Type::INTEGER, value->type());
- actual_int_value = -1;
- EXPECT_TRUE(value->GetAsInteger(&actual_int_value));
- EXPECT_EQ(kUserValue, actual_int_value);
+ ASSERT_TRUE(value->is_int());
+ EXPECT_EQ(kUserValue, value->GetInt());
// Check that GetRecommendedValue() returns the recommended value.
value = pref->GetRecommendedValue();
ASSERT_TRUE(value);
EXPECT_EQ(base::Value::Type::INTEGER, value->type());
- actual_int_value = -1;
- EXPECT_TRUE(value->GetAsInteger(&actual_int_value));
- EXPECT_EQ(kRecommendedValue, actual_int_value);
+ ASSERT_TRUE(value->is_int());
+ EXPECT_EQ(kRecommendedValue, value->GetInt());
// Remove the user-set value.
prefs.RemoveUserPref(kPrefName);
value = pref->GetValue();
ASSERT_TRUE(value);
EXPECT_EQ(base::Value::Type::INTEGER, value->type());
- actual_int_value = -1;
- EXPECT_TRUE(value->GetAsInteger(&actual_int_value));
- EXPECT_EQ(kRecommendedValue, actual_int_value);
+ ASSERT_TRUE(value->is_int());
+ EXPECT_EQ(kRecommendedValue, value->GetInt());
// Check that GetRecommendedValue() returns the recommended value.
value = pref->GetRecommendedValue();
ASSERT_TRUE(value);
EXPECT_EQ(base::Value::Type::INTEGER, value->type());
- actual_int_value = -1;
- EXPECT_TRUE(value->GetAsInteger(&actual_int_value));
- EXPECT_EQ(kRecommendedValue, actual_int_value);
+ ASSERT_TRUE(value->is_int());
+ EXPECT_EQ(kRecommendedValue, value->GetInt());
}
TEST(PrefServiceTest, SetTimeValue_RegularTime) {
TestingPrefServiceSimple prefs;
// Register a non-null time as the default.
- const base::Time default_time = base::Time::FromDeltaSinceWindowsEpoch(
- base::TimeDelta::FromMicroseconds(12345));
+ const base::Time default_time =
+ base::Time::FromDeltaSinceWindowsEpoch(base::Microseconds(12345));
prefs.registry()->RegisterTimePref(kPrefName, default_time);
EXPECT_FALSE(prefs.GetTime(kPrefName).is_null());
TestingPrefServiceSimple prefs;
// Register a non-zero time delta as the default.
- const base::TimeDelta default_delta =
- base::TimeDelta::FromMicroseconds(12345);
+ const base::TimeDelta default_delta = base::Microseconds(12345);
prefs.registry()->RegisterTimeDeltaPref(kPrefName, default_delta);
EXPECT_FALSE(prefs.GetTimeDelta(kPrefName).is_zero());
}
void SetValue(const std::string& key,
- std::unique_ptr<base::Value> value,
+ base::Value value,
uint32_t flags) override {
SetLastWriteFlags(flags);
}
void SetValueSilently(const std::string& key,
- std::unique_ptr<base::Value> value,
+ base::Value value,
uint32_t flags) override {
SetLastWriteFlags(flags);
}
PrefRegistry::LOSSY_PREF | kCustomRegistrationFlag,
WriteablePrefStore::LOSSY_PREF_WRITE_FLAG}};
- for (size_t i = 0; i < arraysize(kRegistrationToWriteFlags); ++i) {
+ for (size_t i = 0; i < std::size(kRegistrationToWriteFlags); ++i) {
RegistrationToWriteFlags entry = kRegistrationToWriteFlags[i];
registry->RegisterDictionaryPref(entry.pref_name,
- std::make_unique<base::DictionaryValue>(),
entry.registration_flags);
SCOPED_TRACE("Currently testing pref with name: " +
std::string(entry.pref_name));
- prefs->GetMutableUserPref(entry.pref_name, base::Value::Type::DICTIONARY);
+ prefs->GetMutableUserPref(entry.pref_name, base::Value::Type::DICT);
EXPECT_TRUE(flag_checker->last_write_flags_set());
EXPECT_EQ(entry.write_flags, flag_checker->GetLastFlagsAndClear());
EXPECT_EQ(entry.write_flags, flag_checker->GetLastFlagsAndClear());
prefs->SetUserPrefValue(entry.pref_name,
- std::make_unique<base::DictionaryValue>());
+ base::Value(base::Value::Type::DICT));
EXPECT_TRUE(flag_checker->last_write_flags_set());
EXPECT_EQ(entry.write_flags, flag_checker->GetLastFlagsAndClear());
}
prefs_.RemoveUserPref(kName);
Mock::VerifyAndClearExpectations(&observer_);
- base::DictionaryValue new_value;
- new_value.SetString(kName, kValue);
+ base::Value::Dict new_value_dict;
+ new_value_dict.Set(kName, kValue);
+ base::Value new_value(std::move(new_value_dict));
observer_.Expect(kName, &new_value);
prefs_.Set(kName, new_value);
Mock::VerifyAndClearExpectations(&observer_);
prefs_.Set(kName, new_value);
Mock::VerifyAndClearExpectations(&observer_);
- base::DictionaryValue empty;
+ base::Value empty((base::Value::Dict()));
observer_.Expect(kName, &empty);
prefs_.Set(kName, empty);
Mock::VerifyAndClearExpectations(&observer_);
prefs_.RemoveUserPref(kName);
Mock::VerifyAndClearExpectations(&observer_);
- base::ListValue new_value;
- new_value.AppendString(kValue);
+ base::Value::List new_value_list;
+ new_value_list.Append(kValue);
+ base::Value new_value(std::move(new_value_list));
observer_.Expect(kName, &new_value);
prefs_.Set(kName, new_value);
Mock::VerifyAndClearExpectations(&observer_);
prefs_.Set(kName, new_value);
Mock::VerifyAndClearExpectations(&observer_);
- base::ListValue empty;
+ base::Value empty((base::Value::List()));
observer_.Expect(kName, &empty);
prefs_.Set(kName, empty);
Mock::VerifyAndClearExpectations(&observer_);
}
+
+class PrefStandaloneBrowserPrefsTest : public testing::Test {
+ protected:
+ PrefStandaloneBrowserPrefsTest()
+ : user_pref_store_(base::MakeRefCounted<TestingPrefStore>()),
+ standalone_browser_pref_store_(
+ base::MakeRefCounted<TestingPrefStore>()),
+ pref_registry_(base::MakeRefCounted<PrefRegistrySimple>()) {}
+
+ ~PrefStandaloneBrowserPrefsTest() override = default;
+
+ void SetUp() override {
+ auto pref_notifier = std::make_unique<PrefNotifierImpl>();
+ auto pref_value_store = std::make_unique<PrefValueStore>(
+ nullptr /* managed_prefs */, nullptr /* supervised_user_prefs */,
+ nullptr /* extension_prefs */, standalone_browser_pref_store_.get(),
+ new TestingPrefStore(), user_pref_store_.get(),
+ nullptr /* recommended_prefs */, pref_registry_->defaults().get(),
+ pref_notifier.get());
+ pref_service_ = std::make_unique<PrefService>(
+ std::move(pref_notifier), std::move(pref_value_store), user_pref_store_,
+ standalone_browser_pref_store_, pref_registry_, base::DoNothing(),
+ false);
+ pref_registry_->RegisterIntegerPref(kStandaloneBrowserPref, 4);
+ }
+
+ std::unique_ptr<PrefService> pref_service_;
+ scoped_refptr<TestingPrefStore> user_pref_store_;
+ scoped_refptr<TestingPrefStore> standalone_browser_pref_store_;
+ scoped_refptr<PrefRegistrySimple> pref_registry_;
+};
+
+// Check that the standalone browser pref store is correctly initialized,
+// written to, read, and has correct precedence.
+TEST_F(PrefStandaloneBrowserPrefsTest, CheckStandaloneBrowserPref) {
+ const PrefService::Preference* preference =
+ pref_service_->FindPreference(kStandaloneBrowserPref);
+ EXPECT_TRUE(preference->IsDefaultValue());
+ EXPECT_EQ(base::Value(4), *(preference->GetValue()));
+ user_pref_store_->SetInteger(kStandaloneBrowserPref, 11);
+ EXPECT_EQ(base::Value(11), *(preference->GetValue()));
+ // The standalone_browser_pref_store has higher precedence.
+ standalone_browser_pref_store_->SetInteger(kStandaloneBrowserPref, 10);
+ ASSERT_EQ(base::Value(10), *(preference->GetValue()));
+ // Removing user_pref_store value shouldn't change the pref value.
+ user_pref_store_->RemoveValue(kStandaloneBrowserPref,
+ WriteablePrefStore::DEFAULT_PREF_WRITE_FLAGS);
+ ASSERT_EQ(base::Value(10), *(preference->GetValue()));
+ // Now removing the standalone_browser_pref_store value should revert the
+ // value to default.
+ standalone_browser_pref_store_->RemoveValue(
+ kStandaloneBrowserPref, WriteablePrefStore::DEFAULT_PREF_WRITE_FLAGS);
+ EXPECT_EQ(base::Value(4), *(preference->GetValue()));
+}
projects / platform / framework / web / chromium-efl.git / blobdiff