base: Rename ValueType to something less redundant as _just_ Type.

chrome/browser/prefs/pref_service.cc

 // Copyright (c) 2011 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 "chrome/browser/prefs/pref_service.h"
 
 #include <algorithm>
 #include <string>
 
 #include "base/command_line.h"
@@ skipping 22 matching lines @@
 #include "content/common/notification_service.h"
 #include "grit/chromium_strings.h"
 #include "grit/generated_resources.h"
 #include "ui/base/l10n/l10n_util.h"
 
 namespace {
 
 // A helper function for RegisterLocalized*Pref that creates a Value* based on
 // the string value in the locale dll.  Because we control the values in a
 // locale dll, this should always return a Value of the appropriate type.
-Value* CreateLocaleDefaultValue(Value::ValueType type, int message_id) {
+Value* CreateLocaleDefaultValue(base::Value::Type type, int message_id) {
   std::string resource_string = l10n_util::GetStringUTF8(message_id);
   DCHECK(!resource_string.empty());
   switch (type) {
     case Value::TYPE_BOOLEAN: {
       if ("true" == resource_string)
         return Value::CreateBooleanValue(true);
       if ("false" == resource_string)
         return Value::CreateBooleanValue(false);
       break;
     }
@@ skipping 577 matching lines @@
   return out;
 }
 
 const PrefService::Preference* PrefService::FindPreference(
     const char* pref_name) const {
   DCHECK(CalledOnValidThread());
   Preference p(this, pref_name, Value::TYPE_NULL);
   PreferenceSet::const_iterator it = prefs_.find(&p);
   if (it != prefs_.end())
     return *it;
-  const Value::ValueType type = default_store_->GetType(pref_name);
+  const base::Value::Type type = default_store_->GetType(pref_name);
   if (type == Value::TYPE_NULL)
     return NULL;
   Preference* new_pref = new Preference(this, pref_name, type);
   prefs_.insert(new_pref);
   return new_pref;
 }
 
 bool PrefService::ReadOnly() const {
   return user_pref_store_->ReadOnly();
 }
@@ skipping 51 matching lines @@
   DCHECK(CalledOnValidThread());
 
   // The main code path takes ownership, but most don't. We'll be safe.
   scoped_ptr<Value> scoped_value(default_value);
 
   if (FindPreference(path)) {
     NOTREACHED() << "Tried to register duplicate pref " << path;
     return;
   }
 
-  Value::ValueType orig_type = default_value->GetType();
+  base::Value::Type orig_type = default_value->GetType();
   DCHECK(orig_type != Value::TYPE_NULL && orig_type != Value::TYPE_BINARY) <<
          "invalid preference type: " << orig_type;
 
   // Hand off ownership.
   default_store_->SetDefaultValue(path, scoped_value.release());
 
   // Register with sync if necessary.
   if (sync_status == SYNCABLE_PREF && pref_sync_associator_.get())
     pref_sync_associator_->RegisterPref(path);
 }
@@ skipping 48 matching lines @@
   std::string result("0");
   bool rv = pref->GetValue()->GetAsString(&result);
   DCHECK(rv);
 
   int64 val;
   base::StringToInt64(result, &val);
   return val;
 }
 
 Value* PrefService::GetMutableUserPref(const char* path,
-                                       Value::ValueType type) {
+                                       base::Value::Type type) {
   CHECK(type == Value::TYPE_DICTIONARY || type == 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;
@@ skipping 43 matching lines @@
 
 SyncableService* PrefService::GetSyncableService() {
   return pref_sync_associator_.get();
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 // PrefService::Preference
 
 PrefService::Preference::Preference(const PrefService* service,
                                     const char* name,
-                                    Value::ValueType type)
+                                    base::Value::Type type)
       : name_(name),
         type_(type),
         pref_service_(service) {
   DCHECK(name);
   DCHECK(service);
 }
 
-Value::ValueType PrefService::Preference::GetType() const {
+base::Value::Type PrefService::Preference::GetType() const {
   return type_;
 }
 
 const Value* PrefService::Preference::GetValue() const {
   DCHECK(pref_service_->FindPreference(name_.c_str())) <<
       "Must register pref before getting its value";
 
   const Value* found_value = NULL;
   if (pref_value_store()->GetValue(name_, type_, &found_value)) {
     DCHECK(found_value->IsType(type_));
@@ skipping 29 matching lines @@
   return pref_value_store()->PrefValueFromDefaultStore(name_.c_str());
 }
 
 bool PrefService::Preference::IsUserModifiable() const {
   return pref_value_store()->PrefValueUserModifiable(name_.c_str());
 }
 
 bool PrefService::Preference::IsExtensionModifiable() const {
   return pref_value_store()->PrefValueExtensionModifiable(name_.c_str());
 }