From 7e3ec42cab40a19413a3dce3dbb57778e5fae1a4 Mon Sep 17 00:00:00 2001 From: "tfarina@chromium.org" Date: Sun, 16 Dec 2012 05:13:21 +0000 Subject: base: Do not use Value::Create* functions. BUG=160586 R=willchan@chromium.org,estade@chromium.org Review URL: https://chromiumcodereview.appspot.com/11519026 git-svn-id: svn://svn.chromium.org/chrome/trunk/src@173368 0039d316-1c4b-4281-b951-d872f2087c98 --- base/json/json_parser.cc | 10 ++-- base/json/json_writer_unittest.cc | 27 ++++----- base/prefs/json_pref_store_unittest.cc | 16 ++--- base/prefs/overlay_user_pref_store_unittest.cc | 48 ++++++++------- base/prefs/pref_value_map.cc | 6 +- base/prefs/pref_value_map_unittest.cc | 42 +++++++------ .../prefs/public/pref_change_registrar_unittest.cc | 17 +++--- base/prefs/testing_pref_store.cc | 6 +- base/values_unittest.cc | 69 +++++++++++----------- 9 files changed, 124 insertions(+), 117 deletions(-) (limited to 'base') diff --git a/base/json/json_parser.cc b/base/json/json_parser.cc index 02295de..4c03a98 100644 --- a/base/json/json_parser.cc +++ b/base/json/json_parser.cc @@ -148,7 +148,7 @@ class JSONStringValue : public base::Value { return true; } virtual Value* DeepCopy() const OVERRIDE { - return Value::CreateStringValue(string_piece_.as_string()); + return new StringValue(string_piece_.as_string()); } virtual bool Equals(const Value* other) const OVERRIDE { std::string other_string; @@ -865,12 +865,12 @@ Value* JSONParser::ConsumeNumber() { int num_int; if (StringToInt(num_string, &num_int)) - return Value::CreateIntegerValue(num_int); + return new FundamentalValue(num_int); double num_double; if (base::StringToDouble(num_string.as_string(), &num_double) && IsFinite(num_double)) { - return Value::CreateDoubleValue(num_double); + return new FundamentalValue(num_double); } return NULL; @@ -906,7 +906,7 @@ Value* JSONParser::ConsumeLiteral() { return NULL; } NextNChars(kTrueLen - 1); - return Value::CreateBooleanValue(true); + return new FundamentalValue(true); } case 'f': { const char* kFalseLiteral = "false"; @@ -917,7 +917,7 @@ Value* JSONParser::ConsumeLiteral() { return NULL; } NextNChars(kFalseLen - 1); - return Value::CreateBooleanValue(false); + return new FundamentalValue(false); } case 'n': { const char* kNullLiteral = "null"; diff --git a/base/json/json_writer_unittest.cc b/base/json/json_writer_unittest.cc index c52a1df4..7ddd7b4 100644 --- a/base/json/json_writer_unittest.cc +++ b/base/json/json_writer_unittest.cc @@ -29,19 +29,19 @@ TEST(JSONWriterTest, Writing) { delete root; // Test Real values should always have a decimal or an 'e'. - root = Value::CreateDoubleValue(1.0); + root = new FundamentalValue(1.0); JSONWriter::Write(root, &output_js); ASSERT_EQ("1.0", output_js); delete root; // Test Real values in the the range (-1, 1) must have leading zeros - root = Value::CreateDoubleValue(0.2); + root = new FundamentalValue(0.2); JSONWriter::Write(root, &output_js); ASSERT_EQ("0.2", output_js); delete root; // Test Real values in the the range (-1, 1) must have leading zeros - root = Value::CreateDoubleValue(-0.8); + root = new FundamentalValue(-0.8); JSONWriter::Write(root, &output_js); ASSERT_EQ("-0.8", output_js); delete root; @@ -56,7 +56,7 @@ TEST(JSONWriterTest, Writing) { inner_dict->SetInteger("inner int", 10); ListValue* inner_list = new ListValue; list->Append(inner_list); - list->Append(Value::CreateBooleanValue(true)); + list->Append(new FundamentalValue(true)); // Test the pretty-printer. JSONWriter::Write(&root_dict, &output_js); @@ -80,18 +80,17 @@ TEST(JSONWriterTest, Writing) { // Test keys with periods DictionaryValue period_dict; - period_dict.SetWithoutPathExpansion("a.b", Value::CreateIntegerValue(3)); - period_dict.SetWithoutPathExpansion("c", Value::CreateIntegerValue(2)); + period_dict.SetWithoutPathExpansion("a.b", new FundamentalValue(3)); + period_dict.SetWithoutPathExpansion("c", new FundamentalValue(2)); DictionaryValue* period_dict2 = new DictionaryValue; - period_dict2->SetWithoutPathExpansion("g.h.i.j", - Value::CreateIntegerValue(1)); + period_dict2->SetWithoutPathExpansion("g.h.i.j", new FundamentalValue(1)); period_dict.SetWithoutPathExpansion("d.e.f", period_dict2); JSONWriter::Write(&period_dict, &output_js); ASSERT_EQ("{\"a.b\":3,\"c\":2,\"d.e.f\":{\"g.h.i.j\":1}}", output_js); DictionaryValue period_dict3; - period_dict3.Set("a.b", Value::CreateIntegerValue(2)); - period_dict3.SetWithoutPathExpansion("a.b", Value::CreateIntegerValue(1)); + period_dict3.Set("a.b", new FundamentalValue(2)); + period_dict3.SetWithoutPathExpansion("a.b", new FundamentalValue(1)); JSONWriter::Write(&period_dict3, &output_js); ASSERT_EQ("{\"a\":{\"b\":2},\"a.b\":1}", output_js); @@ -103,18 +102,18 @@ TEST(JSONWriterTest, Writing) { delete root; ListValue binary_list; - binary_list.Append(Value::CreateIntegerValue(5)); + binary_list.Append(new FundamentalValue(5)); binary_list.Append(BinaryValue::CreateWithCopiedBuffer("asdf", 4)); - binary_list.Append(Value::CreateIntegerValue(2)); + binary_list.Append(new FundamentalValue(2)); JSONWriter::WriteWithOptions(&binary_list, JSONWriter::OPTIONS_OMIT_BINARY_VALUES, &output_js); ASSERT_EQ("[5,2]", output_js); DictionaryValue binary_dict; - binary_dict.Set("a", Value::CreateIntegerValue(5)); + binary_dict.Set("a", new FundamentalValue(5)); binary_dict.Set("b", BinaryValue::CreateWithCopiedBuffer("asdf", 4)); - binary_dict.Set("c", Value::CreateIntegerValue(2)); + binary_dict.Set("c", new FundamentalValue(2)); JSONWriter::WriteWithOptions(&binary_dict, JSONWriter::OPTIONS_OMIT_BINARY_VALUES, &output_js); diff --git a/base/prefs/json_pref_store_unittest.cc b/base/prefs/json_pref_store_unittest.cc index 6b89f9a..dc6f95e 100644 --- a/base/prefs/json_pref_store_unittest.cc +++ b/base/prefs/json_pref_store_unittest.cc @@ -18,6 +18,7 @@ #include "testing/gmock/include/gmock/gmock.h" #include "testing/gtest/include/gtest/gtest.h" +namespace base { namespace { const char kHomePage[] = "homepage"; @@ -46,7 +47,7 @@ class JsonPrefStoreTest : public testing::Test { data_dir_ = data_dir_.AppendASCII("test"); data_dir_ = data_dir_.AppendASCII("data"); data_dir_ = data_dir_.AppendASCII("pref_service"); - LOG(WARNING) << data_dir_.value(); + LOG(WARNING) << data_dir_.value().c_str(); ASSERT_TRUE(file_util::PathExists(data_dir_)); } @@ -115,8 +116,7 @@ void RunBasicJsonPrefStoreTest(JsonPrefStore* pref_store, EXPECT_EQ(FilePath::StringType(FILE_PATH_LITERAL("/usr/local/")), path); FilePath some_path(FILE_PATH_LITERAL("/usr/sbin/")); - pref_store->SetValue(kSomeDirectory, - Value::CreateStringValue(some_path.value())); + pref_store->SetValue(kSomeDirectory, new StringValue(some_path.value())); EXPECT_TRUE(pref_store->GetValue(kSomeDirectory, &actual)); EXPECT_TRUE(actual->GetAsString(&path)); EXPECT_EQ(some_path.value(), path); @@ -127,8 +127,7 @@ void RunBasicJsonPrefStoreTest(JsonPrefStore* pref_store, EXPECT_TRUE(actual->GetAsBoolean(&boolean)); EXPECT_TRUE(boolean); - pref_store->SetValue(kNewWindowsInTabs, - Value::CreateBooleanValue(false)); + pref_store->SetValue(kNewWindowsInTabs, new FundamentalValue(false)); EXPECT_TRUE(pref_store->GetValue(kNewWindowsInTabs, &actual)); EXPECT_TRUE(actual->GetAsBoolean(&boolean)); EXPECT_FALSE(boolean); @@ -137,14 +136,13 @@ void RunBasicJsonPrefStoreTest(JsonPrefStore* pref_store, int integer = 0; EXPECT_TRUE(actual->GetAsInteger(&integer)); EXPECT_EQ(20, integer); - pref_store->SetValue(kMaxTabs, Value::CreateIntegerValue(10)); + pref_store->SetValue(kMaxTabs, new FundamentalValue(10)); EXPECT_TRUE(pref_store->GetValue(kMaxTabs, &actual)); EXPECT_TRUE(actual->GetAsInteger(&integer)); EXPECT_EQ(10, integer); pref_store->SetValue(kLongIntPref, - Value::CreateStringValue( - base::Int64ToString(214748364842LL))); + new StringValue(base::Int64ToString(214748364842LL))); EXPECT_TRUE(pref_store->GetValue(kLongIntPref, &actual)); EXPECT_TRUE(actual->GetAsString(&string_value)); int64 value; @@ -298,3 +296,5 @@ TEST_F(JsonPrefStoreTest, NeedsEmptyValue) { ASSERT_TRUE(file_util::PathExists(golden_output_file)); EXPECT_TRUE(file_util::TextContentsEqual(golden_output_file, pref_file)); } + +} // namespace base diff --git a/base/prefs/overlay_user_pref_store_unittest.cc b/base/prefs/overlay_user_pref_store_unittest.cc index 80d3586..c4e980b 100644 --- a/base/prefs/overlay_user_pref_store_unittest.cc +++ b/base/prefs/overlay_user_pref_store_unittest.cc @@ -3,6 +3,7 @@ // found in the LICENSE file. #include "base/prefs/overlay_user_pref_store.h" + #include "base/prefs/pref_store_observer_mock.h" #include "base/prefs/testing_pref_store.h" #include "base/values.h" @@ -12,6 +13,7 @@ using ::testing::Mock; using ::testing::StrEq; +namespace base { namespace { const char kBrowserWindowPlacement[] = "browser.window_placement"; @@ -47,22 +49,22 @@ TEST_F(OverlayUserPrefStoreTest, Observer) { // Check that underlay first value is reported. EXPECT_CALL(obs, OnPrefValueChanged(StrEq(overlay_key))).Times(1); - underlay_->SetValue(overlay_key, Value::CreateIntegerValue(42)); + underlay_->SetValue(overlay_key, new FundamentalValue(42)); Mock::VerifyAndClearExpectations(&obs); // Check that underlay overwriting is reported. EXPECT_CALL(obs, OnPrefValueChanged(StrEq(overlay_key))).Times(1); - underlay_->SetValue(overlay_key, Value::CreateIntegerValue(43)); + underlay_->SetValue(overlay_key, new FundamentalValue(43)); Mock::VerifyAndClearExpectations(&obs); // Check that overwriting change in overlay is reported. EXPECT_CALL(obs, OnPrefValueChanged(StrEq(overlay_key))).Times(1); - overlay_->SetValue(overlay_key, Value::CreateIntegerValue(44)); + overlay_->SetValue(overlay_key, new FundamentalValue(44)); Mock::VerifyAndClearExpectations(&obs); // Check that hidden underlay change is not reported. EXPECT_CALL(obs, OnPrefValueChanged(StrEq(overlay_key))).Times(0); - underlay_->SetValue(overlay_key, Value::CreateIntegerValue(45)); + underlay_->SetValue(overlay_key, new FundamentalValue(45)); Mock::VerifyAndClearExpectations(&obs); // Check that overlay remove is reported. @@ -77,15 +79,15 @@ TEST_F(OverlayUserPrefStoreTest, Observer) { // Check respecting of silence. EXPECT_CALL(obs, OnPrefValueChanged(StrEq(overlay_key))).Times(0); - overlay_->SetValueSilently(overlay_key, Value::CreateIntegerValue(46)); + overlay_->SetValueSilently(overlay_key, new FundamentalValue(46)); Mock::VerifyAndClearExpectations(&obs); overlay_->RemoveObserver(&obs); // Check successful unsubscription. EXPECT_CALL(obs, OnPrefValueChanged(StrEq(overlay_key))).Times(0); - underlay_->SetValue(overlay_key, Value::CreateIntegerValue(47)); - overlay_->SetValue(overlay_key, Value::CreateIntegerValue(48)); + underlay_->SetValue(overlay_key, new FundamentalValue(47)); + overlay_->SetValue(overlay_key, new FundamentalValue(48)); Mock::VerifyAndClearExpectations(&obs); } @@ -94,7 +96,7 @@ TEST_F(OverlayUserPrefStoreTest, GetAndSet) { EXPECT_FALSE(overlay_->GetValue(overlay_key, &value)); EXPECT_FALSE(underlay_->GetValue(overlay_key, &value)); - underlay_->SetValue(overlay_key, Value::CreateIntegerValue(42)); + underlay_->SetValue(overlay_key, new FundamentalValue(42)); // Value shines through: EXPECT_TRUE(overlay_->GetValue(overlay_key, &value)); @@ -103,7 +105,7 @@ TEST_F(OverlayUserPrefStoreTest, GetAndSet) { EXPECT_TRUE(underlay_->GetValue(overlay_key, &value)); EXPECT_TRUE(base::FundamentalValue(42).Equals(value)); - overlay_->SetValue(overlay_key, Value::CreateIntegerValue(43)); + overlay_->SetValue(overlay_key, new FundamentalValue(43)); EXPECT_TRUE(overlay_->GetValue(overlay_key, &value)); EXPECT_TRUE(base::FundamentalValue(43).Equals(value)); @@ -153,12 +155,12 @@ TEST_F(OverlayUserPrefStoreTest, GlobalPref) { // Check that underlay first value is reported. EXPECT_CALL(obs, OnPrefValueChanged(StrEq(regular_key))).Times(1); - underlay_->SetValue(regular_key, Value::CreateIntegerValue(42)); + underlay_->SetValue(regular_key, new FundamentalValue(42)); Mock::VerifyAndClearExpectations(&obs); // Check that underlay overwriting is reported. EXPECT_CALL(obs, OnPrefValueChanged(StrEq(regular_key))).Times(1); - underlay_->SetValue(regular_key, Value::CreateIntegerValue(43)); + underlay_->SetValue(regular_key, new FundamentalValue(43)); Mock::VerifyAndClearExpectations(&obs); // Check that we get this value from the overlay @@ -167,7 +169,7 @@ TEST_F(OverlayUserPrefStoreTest, GlobalPref) { // Check that overwriting change in overlay is reported. EXPECT_CALL(obs, OnPrefValueChanged(StrEq(regular_key))).Times(1); - overlay_->SetValue(regular_key, Value::CreateIntegerValue(44)); + overlay_->SetValue(regular_key, new FundamentalValue(44)); Mock::VerifyAndClearExpectations(&obs); // Check that we get this value from the overlay and the underlay. @@ -187,15 +189,15 @@ TEST_F(OverlayUserPrefStoreTest, GlobalPref) { // Check respecting of silence. EXPECT_CALL(obs, OnPrefValueChanged(StrEq(regular_key))).Times(0); - overlay_->SetValueSilently(regular_key, Value::CreateIntegerValue(46)); + overlay_->SetValueSilently(regular_key, new FundamentalValue(46)); Mock::VerifyAndClearExpectations(&obs); overlay_->RemoveObserver(&obs); // Check successful unsubscription. EXPECT_CALL(obs, OnPrefValueChanged(StrEq(regular_key))).Times(0); - underlay_->SetValue(regular_key, Value::CreateIntegerValue(47)); - overlay_->SetValue(regular_key, Value::CreateIntegerValue(48)); + underlay_->SetValue(regular_key, new FundamentalValue(47)); + overlay_->SetValue(regular_key, new FundamentalValue(48)); Mock::VerifyAndClearExpectations(&obs); } @@ -209,12 +211,12 @@ TEST_F(OverlayUserPrefStoreTest, NamesMapping) { // Check that if there is no override in the overlay, changing underlay value // is reported as changing an overlay value. EXPECT_CALL(obs, OnPrefValueChanged(StrEq(mapped_overlay_key))).Times(1); - underlay_->SetValue(mapped_underlay_key, Value::CreateIntegerValue(42)); + underlay_->SetValue(mapped_underlay_key, new FundamentalValue(42)); Mock::VerifyAndClearExpectations(&obs); // Check that underlay overwriting is reported. EXPECT_CALL(obs, OnPrefValueChanged(StrEq(mapped_overlay_key))).Times(1); - underlay_->SetValue(mapped_underlay_key, Value::CreateIntegerValue(43)); + underlay_->SetValue(mapped_underlay_key, new FundamentalValue(43)); Mock::VerifyAndClearExpectations(&obs); // Check that we get this value from the overlay with both keys @@ -226,7 +228,7 @@ TEST_F(OverlayUserPrefStoreTest, NamesMapping) { // Check that overwriting change in overlay is reported. EXPECT_CALL(obs, OnPrefValueChanged(StrEq(mapped_overlay_key))).Times(1); - overlay_->SetValue(mapped_overlay_key, Value::CreateIntegerValue(44)); + overlay_->SetValue(mapped_overlay_key, new FundamentalValue(44)); Mock::VerifyAndClearExpectations(&obs); // Check that we get an overriden value from overlay, while reading the @@ -240,7 +242,7 @@ TEST_F(OverlayUserPrefStoreTest, NamesMapping) { // Check that hidden underlay change is not reported. EXPECT_CALL(obs, OnPrefValueChanged(StrEq(mapped_overlay_key))).Times(0); - underlay_->SetValue(mapped_underlay_key, Value::CreateIntegerValue(45)); + underlay_->SetValue(mapped_underlay_key, new FundamentalValue(45)); Mock::VerifyAndClearExpectations(&obs); // Check that overlay remove is reported. @@ -260,7 +262,7 @@ TEST_F(OverlayUserPrefStoreTest, NamesMapping) { // Check respecting of silence. EXPECT_CALL(obs, OnPrefValueChanged(StrEq(mapped_overlay_key))).Times(0); EXPECT_CALL(obs, OnPrefValueChanged(StrEq(mapped_underlay_key))).Times(0); - overlay_->SetValueSilently(mapped_overlay_key, Value::CreateIntegerValue(46)); + overlay_->SetValueSilently(mapped_overlay_key, new FundamentalValue(46)); Mock::VerifyAndClearExpectations(&obs); overlay_->RemoveObserver(&obs); @@ -268,7 +270,9 @@ TEST_F(OverlayUserPrefStoreTest, NamesMapping) { // Check successful unsubscription. EXPECT_CALL(obs, OnPrefValueChanged(StrEq(mapped_overlay_key))).Times(0); EXPECT_CALL(obs, OnPrefValueChanged(StrEq(mapped_underlay_key))).Times(0); - underlay_->SetValue(mapped_underlay_key, Value::CreateIntegerValue(47)); - overlay_->SetValue(mapped_overlay_key, Value::CreateIntegerValue(48)); + underlay_->SetValue(mapped_underlay_key, new FundamentalValue(47)); + overlay_->SetValue(mapped_overlay_key, new FundamentalValue(48)); Mock::VerifyAndClearExpectations(&obs); } + +} // namespace base diff --git a/base/prefs/pref_value_map.cc b/base/prefs/pref_value_map.cc index 48e8fa3..43d2a4c 100644 --- a/base/prefs/pref_value_map.cc +++ b/base/prefs/pref_value_map.cc @@ -96,7 +96,7 @@ bool PrefValueMap::GetBoolean(const std::string& key, } void PrefValueMap::SetBoolean(const std::string& key, bool value) { - SetValue(key, Value::CreateBooleanValue(value)); + SetValue(key, new base::FundamentalValue(value)); } bool PrefValueMap::GetString(const std::string& key, @@ -107,7 +107,7 @@ bool PrefValueMap::GetString(const std::string& key, void PrefValueMap::SetString(const std::string& key, const std::string& value) { - SetValue(key, Value::CreateStringValue(value)); + SetValue(key, new base::StringValue(value)); } bool PrefValueMap::GetInteger(const std::string& key, int* value) const { @@ -116,7 +116,7 @@ bool PrefValueMap::GetInteger(const std::string& key, int* value) const { } void PrefValueMap::SetInteger(const std::string& key, const int value) { - SetValue(key, Value::CreateIntegerValue(value)); + SetValue(key, new base::FundamentalValue(value)); } void PrefValueMap::GetDifferingKeys( diff --git a/base/prefs/pref_value_map_unittest.cc b/base/prefs/pref_value_map_unittest.cc index 48ee747..8cc51ad 100644 --- a/base/prefs/pref_value_map_unittest.cc +++ b/base/prefs/pref_value_map_unittest.cc @@ -7,15 +7,18 @@ #include "base/values.h" #include "testing/gtest/include/gtest/gtest.h" +namespace base { +namespace { + TEST(PrefValueMapTest, SetValue) { PrefValueMap map; const Value* result = NULL; EXPECT_FALSE(map.GetValue("key", &result)); EXPECT_FALSE(result); - EXPECT_TRUE(map.SetValue("key", Value::CreateStringValue("test"))); - EXPECT_FALSE(map.SetValue("key", Value::CreateStringValue("test"))); - EXPECT_TRUE(map.SetValue("key", Value::CreateStringValue("hi mom!"))); + EXPECT_TRUE(map.SetValue("key", new StringValue("test"))); + EXPECT_FALSE(map.SetValue("key", new StringValue("test"))); + EXPECT_TRUE(map.SetValue("key", new StringValue("hi mom!"))); EXPECT_TRUE(map.GetValue("key", &result)); EXPECT_TRUE(StringValue("hi mom!").Equals(result)); @@ -23,7 +26,7 @@ TEST(PrefValueMapTest, SetValue) { TEST(PrefValueMapTest, GetAndSetIntegerValue) { PrefValueMap map; - ASSERT_TRUE(map.SetValue("key", Value::CreateIntegerValue(5))); + ASSERT_TRUE(map.SetValue("key", new FundamentalValue(5))); int int_value = 0; EXPECT_TRUE(map.GetInteger("key", &int_value)); @@ -38,7 +41,7 @@ TEST(PrefValueMapTest, RemoveValue) { PrefValueMap map; EXPECT_FALSE(map.RemoveValue("key")); - EXPECT_TRUE(map.SetValue("key", Value::CreateStringValue("test"))); + EXPECT_TRUE(map.SetValue("key", new StringValue("test"))); EXPECT_TRUE(map.GetValue("key", NULL)); EXPECT_TRUE(map.RemoveValue("key")); @@ -49,7 +52,7 @@ TEST(PrefValueMapTest, RemoveValue) { TEST(PrefValueMapTest, Clear) { PrefValueMap map; - EXPECT_TRUE(map.SetValue("key", Value::CreateStringValue("test"))); + EXPECT_TRUE(map.SetValue("key", new StringValue("test"))); EXPECT_TRUE(map.GetValue("key", NULL)); map.Clear(); @@ -59,9 +62,9 @@ TEST(PrefValueMapTest, Clear) { TEST(PrefValueMapTest, GetDifferingKeys) { PrefValueMap reference; - EXPECT_TRUE(reference.SetValue("b", Value::CreateStringValue("test"))); - EXPECT_TRUE(reference.SetValue("c", Value::CreateStringValue("test"))); - EXPECT_TRUE(reference.SetValue("e", Value::CreateStringValue("test"))); + EXPECT_TRUE(reference.SetValue("b", new StringValue("test"))); + EXPECT_TRUE(reference.SetValue("c", new StringValue("test"))); + EXPECT_TRUE(reference.SetValue("e", new StringValue("test"))); PrefValueMap check; std::vector differing_paths; @@ -73,9 +76,9 @@ TEST(PrefValueMapTest, GetDifferingKeys) { expected_differing_paths.push_back("e"); EXPECT_EQ(expected_differing_paths, differing_paths); - EXPECT_TRUE(check.SetValue("a", Value::CreateStringValue("test"))); - EXPECT_TRUE(check.SetValue("c", Value::CreateStringValue("test"))); - EXPECT_TRUE(check.SetValue("d", Value::CreateStringValue("test"))); + EXPECT_TRUE(check.SetValue("a", new StringValue("test"))); + EXPECT_TRUE(check.SetValue("c", new StringValue("test"))); + EXPECT_TRUE(check.SetValue("d", new StringValue("test"))); reference.GetDifferingKeys(&check, &differing_paths); expected_differing_paths.clear(); @@ -88,14 +91,14 @@ TEST(PrefValueMapTest, GetDifferingKeys) { TEST(PrefValueMapTest, SwapTwoMaps) { PrefValueMap first_map; - EXPECT_TRUE(first_map.SetValue("a", Value::CreateStringValue("test"))); - EXPECT_TRUE(first_map.SetValue("b", Value::CreateStringValue("test"))); - EXPECT_TRUE(first_map.SetValue("c", Value::CreateStringValue("test"))); + EXPECT_TRUE(first_map.SetValue("a", new StringValue("test"))); + EXPECT_TRUE(first_map.SetValue("b", new StringValue("test"))); + EXPECT_TRUE(first_map.SetValue("c", new StringValue("test"))); PrefValueMap second_map; - EXPECT_TRUE(second_map.SetValue("d", Value::CreateStringValue("test"))); - EXPECT_TRUE(second_map.SetValue("e", Value::CreateStringValue("test"))); - EXPECT_TRUE(second_map.SetValue("f", Value::CreateStringValue("test"))); + EXPECT_TRUE(second_map.SetValue("d", new StringValue("test"))); + EXPECT_TRUE(second_map.SetValue("e", new StringValue("test"))); + EXPECT_TRUE(second_map.SetValue("f", new StringValue("test"))); first_map.Swap(&second_map); @@ -107,3 +110,6 @@ TEST(PrefValueMapTest, SwapTwoMaps) { EXPECT_TRUE(second_map.GetValue("b", NULL)); EXPECT_TRUE(second_map.GetValue("c", NULL)); } + +} // namespace +} // namespace base diff --git a/base/prefs/public/pref_change_registrar_unittest.cc b/base/prefs/public/pref_change_registrar_unittest.cc index 515b44a..d194c36 100644 --- a/base/prefs/public/pref_change_registrar_unittest.cc +++ b/base/prefs/public/pref_change_registrar_unittest.cc @@ -13,6 +13,7 @@ using testing::Mock; using testing::Eq; +namespace base { namespace { const char kHomePage[] = "homepage"; @@ -39,7 +40,7 @@ class PrefChangeRegistrarTest : public testing::Test { virtual ~PrefChangeRegistrarTest() {} protected: - virtual void SetUp(); + virtual void SetUp() OVERRIDE; base::Closure observer() const { return base::Bind(&base::DoNothing); @@ -163,10 +164,10 @@ TEST_F(ObserveSetOfPreferencesTest, IsManaged) { scoped_ptr pref_set(CreatePrefChangeRegistrar()); EXPECT_FALSE(pref_set->IsManaged()); pref_service_->SetManagedPref(kHomePage, - Value::CreateStringValue("http://crbug.com")); + new StringValue("http://crbug.com")); EXPECT_TRUE(pref_set->IsManaged()); pref_service_->SetManagedPref(kHomePageIsNewTabPage, - Value::CreateBooleanValue(true)); + new FundamentalValue(true)); EXPECT_TRUE(pref_set->IsManaged()); pref_service_->RemoveManagedPref(kHomePage); EXPECT_TRUE(pref_set->IsManaged()); @@ -187,17 +188,17 @@ TEST_F(ObserveSetOfPreferencesTest, Observe) { pref_set.Add(kHomePageIsNewTabPage, callback); EXPECT_CALL(*this, OnPreferenceChanged(kHomePage)); - pref_service_->SetUserPref(kHomePage, - Value::CreateStringValue("http://crbug.com")); + pref_service_->SetUserPref(kHomePage, new StringValue("http://crbug.com")); Mock::VerifyAndClearExpectations(this); EXPECT_CALL(*this, OnPreferenceChanged(kHomePageIsNewTabPage)); pref_service_->SetUserPref(kHomePageIsNewTabPage, - Value::CreateBooleanValue(true)); + new FundamentalValue(true)); Mock::VerifyAndClearExpectations(this); EXPECT_CALL(*this, OnPreferenceChanged(_)).Times(0); - pref_service_->SetUserPref(kApplicationLocale, - Value::CreateStringValue("en_US.utf8")); + pref_service_->SetUserPref(kApplicationLocale, new StringValue("en_US.utf8")); Mock::VerifyAndClearExpectations(this); } + +} // namespace base diff --git a/base/prefs/testing_pref_store.cc b/base/prefs/testing_pref_store.cc index d40fb8a..85f35bb 100644 --- a/base/prefs/testing_pref_store.cc +++ b/base/prefs/testing_pref_store.cc @@ -92,15 +92,15 @@ void TestingPrefStore::ReportValueChanged(const std::string& key) { void TestingPrefStore::SetString(const std::string& key, const std::string& value) { - SetValue(key, Value::CreateStringValue(value)); + SetValue(key, new base::StringValue(value)); } void TestingPrefStore::SetInteger(const std::string& key, int value) { - SetValue(key, Value::CreateIntegerValue(value)); + SetValue(key, new base::FundamentalValue(value)); } void TestingPrefStore::SetBoolean(const std::string& key, bool value) { - SetValue(key, Value::CreateBooleanValue(value)); + SetValue(key, new base::FundamentalValue(value)); } bool TestingPrefStore::GetString(const std::string& key, diff --git a/base/values_unittest.cc b/base/values_unittest.cc index 9b92949..8a42f78 100644 --- a/base/values_unittest.cc +++ b/base/values_unittest.cc @@ -20,7 +20,7 @@ TEST(ValuesTest, Basic) { ASSERT_EQ(std::string("http://google.com"), homepage); ASSERT_FALSE(settings.Get("global", NULL)); - settings.Set("global", Value::CreateBooleanValue(true)); + settings.Set("global", new FundamentalValue(true)); ASSERT_TRUE(settings.Get("global", NULL)); settings.SetString("global.homepage", "http://scurvy.com"); ASSERT_TRUE(settings.Get("global", NULL)); @@ -57,10 +57,10 @@ TEST(ValuesTest, Basic) { TEST(ValuesTest, List) { scoped_ptr mixed_list(new ListValue()); - mixed_list->Set(0, Value::CreateBooleanValue(true)); - mixed_list->Set(1, Value::CreateIntegerValue(42)); - mixed_list->Set(2, Value::CreateDoubleValue(88.8)); - mixed_list->Set(3, Value::CreateStringValue("foo")); + mixed_list->Set(0, new FundamentalValue(true)); + mixed_list->Set(1, new FundamentalValue(42)); + mixed_list->Set(2, new FundamentalValue(88.8)); + mixed_list->Set(3, new StringValue("foo")); ASSERT_EQ(4u, mixed_list->GetSize()); Value *value = NULL; @@ -95,13 +95,13 @@ TEST(ValuesTest, List) { ASSERT_EQ("foo", string_value); // Try searching in the mixed list. - scoped_ptr sought_value(Value::CreateIntegerValue(42)); - scoped_ptr not_found_value(Value::CreateBooleanValue(false)); + base::FundamentalValue sought_value(42); + base::FundamentalValue not_found_value(false); - ASSERT_NE(mixed_list->end(), mixed_list->Find(*sought_value)); - ASSERT_TRUE((*mixed_list->Find(*sought_value))->GetAsInteger(&int_value)); + ASSERT_NE(mixed_list->end(), mixed_list->Find(sought_value)); + ASSERT_TRUE((*mixed_list->Find(sought_value))->GetAsInteger(&int_value)); ASSERT_EQ(42, int_value); - ASSERT_EQ(mixed_list->end(), mixed_list->Find(*not_found_value)); + ASSERT_EQ(mixed_list->end(), mixed_list->Find(not_found_value)); } TEST(ValuesTest, BinaryValue) { @@ -139,11 +139,10 @@ TEST(ValuesTest, BinaryValue) { TEST(ValuesTest, StringValue) { // Test overloaded CreateStringValue. - scoped_ptr narrow_value(Value::CreateStringValue("narrow")); + scoped_ptr narrow_value(new StringValue("narrow")); ASSERT_TRUE(narrow_value.get()); ASSERT_TRUE(narrow_value->IsType(Value::TYPE_STRING)); - scoped_ptr utf16_value( - Value::CreateStringValue(ASCIIToUTF16("utf16"))); + scoped_ptr utf16_value(new StringValue(ASCIIToUTF16("utf16"))); ASSERT_TRUE(utf16_value.get()); ASSERT_TRUE(utf16_value->IsType(Value::TYPE_STRING)); @@ -338,16 +337,15 @@ TEST(ValuesTest, DeepCopy) { DictionaryValue original_dict; Value* original_null = Value::CreateNullValue(); original_dict.Set("null", original_null); - FundamentalValue* original_bool = Value::CreateBooleanValue(true); + FundamentalValue* original_bool = new FundamentalValue(true); original_dict.Set("bool", original_bool); - FundamentalValue* original_int = Value::CreateIntegerValue(42); + FundamentalValue* original_int = new FundamentalValue(42); original_dict.Set("int", original_int); - FundamentalValue* original_double = Value::CreateDoubleValue(3.14); + FundamentalValue* original_double = new FundamentalValue(3.14); original_dict.Set("double", original_double); - StringValue* original_string = Value::CreateStringValue("hello"); + StringValue* original_string = new StringValue("hello"); original_dict.Set("string", original_string); - StringValue* original_string16 = - Value::CreateStringValue(ASCIIToUTF16("hello16")); + StringValue* original_string16 = new StringValue(ASCIIToUTF16("hello16")); original_dict.Set("string16", original_string16); char* original_buffer = new char[42]; @@ -356,14 +354,14 @@ TEST(ValuesTest, DeepCopy) { original_dict.Set("binary", original_binary); ListValue* original_list = new ListValue(); - FundamentalValue* original_list_element_0 = Value::CreateIntegerValue(0); + FundamentalValue* original_list_element_0 = new FundamentalValue(0); original_list->Append(original_list_element_0); - FundamentalValue* original_list_element_1 = Value::CreateIntegerValue(1); + FundamentalValue* original_list_element_1 = new FundamentalValue(1); original_list->Append(original_list_element_1); original_dict.Set("list", original_list); DictionaryValue* original_nested_dictionary = new DictionaryValue(); - original_nested_dictionary->Set("key", Value::CreateStringValue("value")); + original_nested_dictionary->Set("key", new StringValue("value")); original_dict.Set("dictionary", original_nested_dictionary); scoped_ptr copy_dict(original_dict.DeepCopy()); @@ -481,7 +479,7 @@ TEST(ValuesTest, Equals) { EXPECT_NE(null1, null2); EXPECT_TRUE(null1->Equals(null2)); - Value* boolean = Value::CreateBooleanValue(false); + Value* boolean = new FundamentalValue(false); EXPECT_FALSE(null1->Equals(boolean)); delete null1; delete null2; @@ -508,7 +506,7 @@ TEST(ValuesTest, Equals) { copy->Set("f", list->DeepCopy()); EXPECT_TRUE(dv.Equals(copy.get())); - list->Append(Value::CreateBooleanValue(true)); + list->Append(new FundamentalValue(true)); EXPECT_FALSE(dv.Equals(copy.get())); // Check if Equals detects differences in only the keys. @@ -525,9 +523,9 @@ TEST(ValuesTest, StaticEquals) { EXPECT_TRUE(Value::Equals(null1.get(), null2.get())); EXPECT_TRUE(Value::Equals(NULL, NULL)); - scoped_ptr i42(Value::CreateIntegerValue(42)); - scoped_ptr j42(Value::CreateIntegerValue(42)); - scoped_ptr i17(Value::CreateIntegerValue(17)); + scoped_ptr i42(new FundamentalValue(42)); + scoped_ptr j42(new FundamentalValue(42)); + scoped_ptr i17(new FundamentalValue(17)); EXPECT_TRUE(Value::Equals(i42.get(), i42.get())); EXPECT_TRUE(Value::Equals(j42.get(), i42.get())); EXPECT_TRUE(Value::Equals(i42.get(), j42.get())); @@ -546,16 +544,15 @@ TEST(ValuesTest, DeepCopyCovariantReturnTypes) { DictionaryValue original_dict; Value* original_null = Value::CreateNullValue(); original_dict.Set("null", original_null); - FundamentalValue* original_bool = Value::CreateBooleanValue(true); + FundamentalValue* original_bool = new FundamentalValue(true); original_dict.Set("bool", original_bool); - FundamentalValue* original_int = Value::CreateIntegerValue(42); + FundamentalValue* original_int = new FundamentalValue(42); original_dict.Set("int", original_int); - FundamentalValue* original_double = Value::CreateDoubleValue(3.14); + FundamentalValue* original_double = new FundamentalValue(3.14); original_dict.Set("double", original_double); - StringValue* original_string = Value::CreateStringValue("hello"); + StringValue* original_string = new StringValue("hello"); original_dict.Set("string", original_string); - StringValue* original_string16 = - Value::CreateStringValue(ASCIIToUTF16("hello16")); + StringValue* original_string16 = new StringValue(ASCIIToUTF16("hello16")); original_dict.Set("string16", original_string16); char* original_buffer = new char[42]; @@ -564,9 +561,9 @@ TEST(ValuesTest, DeepCopyCovariantReturnTypes) { original_dict.Set("binary", original_binary); ListValue* original_list = new ListValue(); - FundamentalValue* original_list_element_0 = Value::CreateIntegerValue(0); + FundamentalValue* original_list_element_0 = new FundamentalValue(0); original_list->Append(original_list_element_0); - FundamentalValue* original_list_element_1 = Value::CreateIntegerValue(1); + FundamentalValue* original_list_element_1 = new FundamentalValue(1); original_list->Append(original_list_element_1); original_dict.Set("list", original_list); @@ -663,7 +660,7 @@ TEST(ValuesTest, RemoveEmptyChildren) { ListValue* inner2 = new ListValue; inner->Append(new DictionaryValue); inner->Append(inner2); - inner2->Append(Value::CreateStringValue("hello")); + inner2->Append(new StringValue("hello")); root.reset(root->DeepCopyWithoutEmptyChildren()); EXPECT_EQ(3U, root->size()); EXPECT_TRUE(root->GetList("list_with_empty_children", &inner)); -- cgit v1.1