Make base::Value::TYPE a scoped enum.

components/prefs/pref_service_unittest.cc

 // Copyright (c) 2012 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 <stddef.h>
 #include <stdint.h>
 
 #include <string>
 
 #include "base/macros.h"
@@ skipping 130 matching lines @@
   TestingPrefServiceSimple prefs;
   prefs.registry()->RegisterIntegerPref(kPrefName, kTestValue);
 
   // Check falling back to a recommended value.
   prefs.SetUserPref(kPrefName,
                     new base::StringValue("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->GetType());
+  EXPECT_EQ(base::Value::Type::INTEGER, value->GetType());
   int actual_int_value = -1;
   EXPECT_TRUE(value->GetAsInteger(&actual_int_value));
   EXPECT_EQ(kTestValue, actual_int_value);
 }
 
 TEST(PrefServiceTest, GetValueAndGetRecommendedValue) {
   const int kDefaultValue = 5;
   const int kUserValue = 10;
   const int kRecommendedValue = 15;
   TestingPrefServiceSimple prefs;
   prefs.registry()->RegisterIntegerPref(kPrefName, kDefaultValue);
 
   // Create pref with a default value only.
   const PrefService::Preference* pref = prefs.FindPreference(kPrefName);
   ASSERT_TRUE(pref);
 
   // Check that GetValue() returns the default value.
   const base::Value* value = pref->GetValue();
   ASSERT_TRUE(value);
-  EXPECT_EQ(base::Value::TYPE_INTEGER, value->GetType());
+  EXPECT_EQ(base::Value::Type::INTEGER, value->GetType());
   int actual_int_value = -1;
   EXPECT_TRUE(value->GetAsInteger(&actual_int_value));
   EXPECT_EQ(kDefaultValue, actual_int_value);
 
   // Check that GetRecommendedValue() returns no value.
   value = pref->GetRecommendedValue();
   ASSERT_FALSE(value);
 
   // Set a user-set value.
   prefs.SetUserPref(kPrefName, new base::FundamentalValue(kUserValue));
 
   // Check that GetValue() returns the user-set value.
   value = pref->GetValue();
   ASSERT_TRUE(value);
-  EXPECT_EQ(base::Value::TYPE_INTEGER, value->GetType());
+  EXPECT_EQ(base::Value::Type::INTEGER, value->GetType());
   actual_int_value = -1;
   EXPECT_TRUE(value->GetAsInteger(&actual_int_value));
   EXPECT_EQ(kUserValue, actual_int_value);
 
   // Check that GetRecommendedValue() returns no value.
   value = pref->GetRecommendedValue();
   ASSERT_FALSE(value);
 
   // Set a recommended value.
   prefs.SetRecommendedPref(kPrefName,
                            new base::FundamentalValue(kRecommendedValue));
 
   // Check that GetValue() returns the user-set value.
   value = pref->GetValue();
   ASSERT_TRUE(value);
-  EXPECT_EQ(base::Value::TYPE_INTEGER, value->GetType());
+  EXPECT_EQ(base::Value::Type::INTEGER, value->GetType());
   actual_int_value = -1;
   EXPECT_TRUE(value->GetAsInteger(&actual_int_value));
   EXPECT_EQ(kUserValue, actual_int_value);
 
   // Check that GetRecommendedValue() returns the recommended value.
   value = pref->GetRecommendedValue();
   ASSERT_TRUE(value);
-  EXPECT_EQ(base::Value::TYPE_INTEGER, value->GetType());
+  EXPECT_EQ(base::Value::Type::INTEGER, value->GetType());
   actual_int_value = -1;
   EXPECT_TRUE(value->GetAsInteger(&actual_int_value));
   EXPECT_EQ(kRecommendedValue, actual_int_value);
 
   // Remove the user-set value.
   prefs.RemoveUserPref(kPrefName);
 
   // Check that GetValue() returns the recommended value.
   value = pref->GetValue();
   ASSERT_TRUE(value);
-  EXPECT_EQ(base::Value::TYPE_INTEGER, value->GetType());
+  EXPECT_EQ(base::Value::Type::INTEGER, value->GetType());
   actual_int_value = -1;
   EXPECT_TRUE(value->GetAsInteger(&actual_int_value));
   EXPECT_EQ(kRecommendedValue, actual_int_value);
 
   // Check that GetRecommendedValue() returns the recommended value.
   value = pref->GetRecommendedValue();
   ASSERT_TRUE(value);
-  EXPECT_EQ(base::Value::TYPE_INTEGER, value->GetType());
+  EXPECT_EQ(base::Value::Type::INTEGER, value->GetType());
   actual_int_value = -1;
   EXPECT_TRUE(value->GetAsInteger(&actual_int_value));
   EXPECT_EQ(kRecommendedValue, actual_int_value);
 }
 
 // A PrefStore which just stores the last write flags that were used to write
 // values to it.
 class WriteFlagChecker : public TestingPrefStore {
  public:
   WriteFlagChecker() {}
@@ skipping 74 matching lines @@
        WriteablePrefStore::LOSSY_PREF_WRITE_FLAG}};
 
   for (size_t i = 0; i < arraysize(kRegistrationToWriteFlags); ++i) {
     RegistrationToWriteFlags entry = kRegistrationToWriteFlags[i];
     registry->RegisterDictionaryPref(
         entry.pref_name, new 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::DICTIONARY);
     EXPECT_TRUE(flag_checker->last_write_flags_set());
     EXPECT_EQ(entry.write_flags, flag_checker->GetLastFlagsAndClear());
 
     prefs->ReportUserPrefChanged(entry.pref_name);
     EXPECT_TRUE(flag_checker->last_write_flags_set());
     EXPECT_EQ(entry.write_flags, flag_checker->GetLastFlagsAndClear());
 
     prefs->ClearPref(entry.pref_name);
     EXPECT_TRUE(flag_checker->last_write_flags_set());
     EXPECT_EQ(entry.write_flags, flag_checker->GetLastFlagsAndClear());
@@ skipping 86 matching lines @@
 
   EXPECT_CALL(observer_, OnPreferenceChanged(_)).Times(0);
   prefs_.Set(kName, new_value);
   Mock::VerifyAndClearExpectations(&observer_);
 
   base::ListValue empty;
   observer_.Expect(kName, &empty);
   prefs_.Set(kName, empty);
   Mock::VerifyAndClearExpectations(&observer_);
 }