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

components/prefs/pref_service.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 "components/prefs/pref_service.h"
 
 #include <algorithm>
 #include <utility>
 
 #include "base/bind.h"
@@ skipping 270 matching lines @@
 
 const base::DictionaryValue* PrefService::GetDictionary(
     const std::string& path) const {
   DCHECK(CalledOnValidThread());
 
   const base::Value* value = GetPreferenceValue(path);
   if (!value) {
     NOTREACHED() << "Trying to read an unregistered pref: " << path;
     return NULL;
   }
-  if (value->GetType() != base::Value::TYPE_DICTIONARY) {
+  if (value->GetType() != base::Value::Type::DICTIONARY) {
     NOTREACHED();
     return NULL;
   }
   return static_cast<const base::DictionaryValue*>(value);
 }
 
 const base::Value* PrefService::GetUserPrefValue(
     const std::string& path) const {
   DCHECK(CalledOnValidThread());
 
@@ skipping 36 matching lines @@
 }
 
 const base::ListValue* PrefService::GetList(const std::string& path) const {
   DCHECK(CalledOnValidThread());
 
   const base::Value* value = GetPreferenceValue(path);
   if (!value) {
     NOTREACHED() << "Trying to read an unregistered pref: " << path;
     return NULL;
   }
-  if (value->GetType() != base::Value::TYPE_LIST) {
+  if (value->GetType() != base::Value::Type::LIST) {
     NOTREACHED();
     return NULL;
   }
   return static_cast<const base::ListValue*>(value);
 }
 
 void PrefService::AddPrefObserver(const std::string& path, PrefObserver* obs) {
   pref_notifier_->AddPrefObserver(path, obs);
 }
 
@@ skipping 87 matching lines @@
   bool rv = value->GetAsString(&result);
   DCHECK(rv);
 
   uint64_t val;
   base::StringToUint64(result, &val);
   return val;
 }
 
 base::Value* PrefService::GetMutableUserPref(const std::string& path,
                                              base::Value::Type type) {
-  CHECK(type == base::Value::TYPE_DICTIONARY || type == base::Value::TYPE_LIST);
+  CHECK(type == base::Value::Type::DICTIONARY ||
+        type == base::Value::Type::LIST);
   DCHECK(CalledOnValidThread());
 
   const Preference* pref = FindPreference(path);
   if (!pref) {
     NOTREACHED() << "Trying to get an unregistered pref: " << path;
     return NULL;
   }
   if (pref->GetType() != type) {
     NOTREACHED() << "Wrong type for GetMutableValue: " << path;
     return NULL;
   }
 
   // Look for an existing preference in the user store. If it doesn't
   // exist or isn't the correct type, create a new user preference.
   base::Value* value = NULL;
   if (!user_pref_store_->GetMutableValue(path, &value) ||
       !value->IsType(type)) {
-    if (type == base::Value::TYPE_DICTIONARY) {
+    if (type == base::Value::Type::DICTIONARY) {
       value = new base::DictionaryValue;
-    } else if (type == base::Value::TYPE_LIST) {
+    } else if (type == base::Value::Type::LIST) {
       value = new base::ListValue;
     } else {
       NOTREACHED();
     }
     user_pref_store_->SetValueSilently(path, base::WrapUnique(value),
                                        GetWriteFlags(pref));
   }
   return value;
 }
 
@@ skipping 126 matching lines @@
       DCHECK(found_value->IsType(default_type));
       return found_value;
     } else {
       // Every registered preference has at least a default value.
       NOTREACHED() << "no valid value found for registered pref " << path;
     }
   }
 
   return NULL;
 }