Make base use the proper Value namespace

base/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 "base/prefs/pref_service.h"
 
 #include <algorithm>
 
 #include "base/bind.h"
 #include "base/files/file_path.h"
@@ skipping 159 matching lines @@
   bool rv = base::GetValueAsFilePath(*value, &result);
   DCHECK(rv);
   return result;
 }
 
 bool PrefService::HasPrefPath(const char* path) const {
   const Preference* pref = FindPreference(path);
   return pref && !pref->IsDefaultValue();
 }
 
-DictionaryValue* PrefService::GetPreferenceValues() const {
+base::DictionaryValue* PrefService::GetPreferenceValues() const {
   DCHECK(CalledOnValidThread());
-  DictionaryValue* out = new DictionaryValue;
+  base::DictionaryValue* out = new base::DictionaryValue;
   PrefRegistry::const_iterator i = pref_registry_->begin();
   for (; i != pref_registry_->end(); ++i) {
-    const Value* value = GetPreferenceValue(i->first);
+    const base::Value* value = GetPreferenceValue(i->first);
     DCHECK(value);
     out->Set(i->first, value->DeepCopy());
   }
   return out;
 }
 
 const PrefService::Preference* PrefService::FindPreference(
     const char* pref_name) const {
   DCHECK(CalledOnValidThread());
   PreferenceMap::iterator it = prefs_map_.find(pref_name);
@@ skipping 30 matching lines @@
 bool PrefService::IsManagedPreference(const char* pref_name) const {
   const Preference* pref = FindPreference(pref_name);
   return pref && pref->IsManaged();
 }
 
 bool PrefService::IsUserModifiablePreference(const char* pref_name) const {
   const Preference* pref = FindPreference(pref_name);
   return pref && pref->IsUserModifiable();
 }
 
-const DictionaryValue* PrefService::GetDictionary(const char* path) const {
+const base::DictionaryValue* PrefService::GetDictionary(
+    const char* path) const {
   DCHECK(CalledOnValidThread());
 
-  const Value* value = GetPreferenceValue(path);
+  const base::Value* value = GetPreferenceValue(path);
   if (!value) {
     NOTREACHED() << "Trying to read an unregistered pref: " << path;
     return NULL;
   }
-  if (value->GetType() != Value::TYPE_DICTIONARY) {
+  if (value->GetType() != base::Value::TYPE_DICTIONARY) {
     NOTREACHED();
     return NULL;
   }
-  return static_cast<const DictionaryValue*>(value);
+  return static_cast<const base::DictionaryValue*>(value);
 }
 
 const base::Value* PrefService::GetUserPrefValue(const char* path) const {
   DCHECK(CalledOnValidThread());
 
   const Preference* pref = FindPreference(path);
   if (!pref) {
     NOTREACHED() << "Trying to get an unregistered pref: " << path;
     return NULL;
   }
@@ skipping 22 matching lines @@
   DCHECK(CalledOnValidThread());
   // Lookup the preference in the default store.
   const base::Value* value = NULL;
   if (!pref_registry_->defaults()->GetValue(path, &value)) {
     NOTREACHED() << "Default value missing for pref: " << path;
     return NULL;
   }
   return value;
 }
 
-const ListValue* PrefService::GetList(const char* path) const {
+const base::ListValue* PrefService::GetList(const char* path) const {
   DCHECK(CalledOnValidThread());
 
-  const Value* value = GetPreferenceValue(path);
+  const base::Value* value = GetPreferenceValue(path);
   if (!value) {
     NOTREACHED() << "Trying to read an unregistered pref: " << path;
     return NULL;
   }
-  if (value->GetType() != Value::TYPE_LIST) {
+  if (value->GetType() != base::Value::TYPE_LIST) {
     NOTREACHED();
     return NULL;
   }
-  return static_cast<const ListValue*>(value);
+  return static_cast<const base::ListValue*>(value);
 }
 
 void PrefService::AddPrefObserver(const char* path, PrefObserver* obs) {
   pref_notifier_->AddPrefObserver(path, obs);
 }
 
 void PrefService::RemovePrefObserver(const char* path, PrefObserver* obs) {
   pref_notifier_->RemovePrefObserver(path, obs);
 }
 
@@ skipping 12 matching lines @@
     AddRegisteredPreference(it->first.c_str(), it->second);
   }
 }
 
 // TODO(joi): Once MarkNeedsEmptyValue is gone, we can probably
 // completely get rid of this method. There will be one difference in
 // semantics; currently all registered preferences are stored right
 // away in the prefs_map_, if we remove this they would be stored only
 // opportunistically.
 void PrefService::AddRegisteredPreference(const char* path,
-                                          Value* default_value) {
+                                          base::Value* default_value) {
   DCHECK(CalledOnValidThread());
 
   // For ListValue and DictionaryValue with non empty default, empty value
   // for |path| needs to be persisted in |user_pref_store_|. So that
   // non empty default is not used when user sets an empty ListValue or
   // DictionaryValue.
   bool needs_empty_value = false;
   base::Value::Type orig_type = default_value->GetType();
   if (orig_type == base::Value::TYPE_LIST) {
     const base::ListValue* list = NULL;
@@ skipping 12 matching lines @@
   DCHECK(CalledOnValidThread());
 
   const Preference* pref = FindPreference(path);
   if (!pref) {
     NOTREACHED() << "Trying to clear an unregistered pref: " << path;
     return;
   }
   user_pref_store_->RemoveValue(path);
 }
 
-void PrefService::Set(const char* path, const Value& value) {
+void PrefService::Set(const char* path, const base::Value& value) {
   SetUserPrefValue(path, value.DeepCopy());
 }
 
 void PrefService::SetBoolean(const char* path, bool value) {
-  SetUserPrefValue(path, Value::CreateBooleanValue(value));
+  SetUserPrefValue(path, base::Value::CreateBooleanValue(value));
 }
 
 void PrefService::SetInteger(const char* path, int value) {
-  SetUserPrefValue(path, Value::CreateIntegerValue(value));
+  SetUserPrefValue(path, base::Value::CreateIntegerValue(value));
 }
 
 void PrefService::SetDouble(const char* path, double value) {
-  SetUserPrefValue(path, Value::CreateDoubleValue(value));
+  SetUserPrefValue(path, base::Value::CreateDoubleValue(value));
 }
 
 void PrefService::SetString(const char* path, const std::string& value) {
-  SetUserPrefValue(path, Value::CreateStringValue(value));
+  SetUserPrefValue(path, base::Value::CreateStringValue(value));
 }
 
 void PrefService::SetFilePath(const char* path, const base::FilePath& value) {
   SetUserPrefValue(path, base::CreateFilePathValue(value));
 }
 
 void PrefService::SetInt64(const char* path, int64 value) {
-  SetUserPrefValue(path, Value::CreateStringValue(base::Int64ToString(value)));
+  SetUserPrefValue(path,
+                   base::Value::CreateStringValue(base::Int64ToString(value)));
 }
 
 int64 PrefService::GetInt64(const char* path) const {
   DCHECK(CalledOnValidThread());
 
-  const Value* value = GetPreferenceValue(path);
+  const base::Value* value = GetPreferenceValue(path);
   if (!value) {
     NOTREACHED() << "Trying to read an unregistered pref: " << path;
     return 0;
   }
   std::string result("0");
   bool rv = value->GetAsString(&result);
   DCHECK(rv);
 
   int64 val;
   base::StringToInt64(result, &val);
   return val;
 }
 
 void PrefService::SetUint64(const char* path, uint64 value) {
-  SetUserPrefValue(path, Value::CreateStringValue(base::Uint64ToString(value)));
+  SetUserPrefValue(path,
+                   base::Value::CreateStringValue(base::Uint64ToString(value)));
 }
 
 uint64 PrefService::GetUint64(const char* path) const {
   DCHECK(CalledOnValidThread());
 
-  const Value* value = GetPreferenceValue(path);
+  const base::Value* value = GetPreferenceValue(path);
   if (!value) {
     NOTREACHED() << "Trying to read an unregistered pref: " << path;
     return 0;
   }
   std::string result("0");
   bool rv = value->GetAsString(&result);
   DCHECK(rv);
 
   uint64 val;
   base::StringToUint64(result, &val);
   return val;
 }
 
-Value* PrefService::GetMutableUserPref(const char* path,
-                                       base::Value::Type type) {
-  CHECK(type == Value::TYPE_DICTIONARY || type == Value::TYPE_LIST);
+base::Value* PrefService::GetMutableUserPref(const char* path,
+                                             base::Value::Type type) {
+  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.
-  Value* value = NULL;
+  base::Value* value = NULL;
   if (!user_pref_store_->GetMutableValue(path, &value) ||
       !value->IsType(type)) {
-    if (type == Value::TYPE_DICTIONARY) {
-      value = new DictionaryValue;
-    } else if (type == Value::TYPE_LIST) {
-      value = new ListValue;
+    if (type == base::Value::TYPE_DICTIONARY) {
+      value = new base::DictionaryValue;
+    } else if (type == base::Value::TYPE_LIST) {
+      value = new base::ListValue;
     } else {
       NOTREACHED();
     }
     user_pref_store_->SetValueSilently(path, value);
   }
   return value;
 }
 
 void PrefService::ReportUserPrefChanged(const std::string& key) {
   user_pref_store_->ReportValueChanged(key);
 }
 
-void PrefService::SetUserPrefValue(const char* path, Value* new_value) {
-  scoped_ptr<Value> owned_value(new_value);
+void PrefService::SetUserPrefValue(const char* path, base::Value* new_value) {
+  scoped_ptr<base::Value> owned_value(new_value);
   DCHECK(CalledOnValidThread());
 
   const Preference* pref = FindPreference(path);
   if (!pref) {
     NOTREACHED() << "Trying to write an unregistered pref: " << path;
     return;
   }
   if (pref->GetType() != new_value->GetType()) {
     NOTREACHED() << "Trying to set pref " << path
                  << " of type " << pref->GetType()
@@ skipping 22 matching lines @@
 }
 
 const std::string PrefService::Preference::name() const {
   return name_;
 }
 
 base::Value::Type PrefService::Preference::GetType() const {
   return type_;
 }
 
-const Value* PrefService::Preference::GetValue() const {
-  const Value* result= pref_service_->GetPreferenceValue(name_);
+const base::Value* PrefService::Preference::GetValue() const {
+  const base::Value* result= pref_service_->GetPreferenceValue(name_);
   DCHECK(result) << "Must register pref before getting its value";
   return result;
 }
 
-const Value* PrefService::Preference::GetRecommendedValue() const {
+const base::Value* PrefService::Preference::GetRecommendedValue() const {
   DCHECK(pref_service_->FindPreference(name_.c_str())) <<
       "Must register pref before getting its value";
 
-  const Value* found_value = NULL;
+  const base::Value* found_value = NULL;
   if (pref_value_store()->GetRecommendedValue(name_, type_, &found_value)) {
     DCHECK(found_value->IsType(type_));
     return found_value;
   }
 
   // The pref has no recommended value.
   return NULL;
 }
 
 bool PrefService::Preference::IsManaged() const {
@@ skipping 28 matching lines @@
   return pref_value_store()->PrefValueUserModifiable(name_.c_str());
 }
 
 bool PrefService::Preference::IsExtensionModifiable() const {
   return pref_value_store()->PrefValueExtensionModifiable(name_.c_str());
 }
 
 const base::Value* PrefService::GetPreferenceValue(
     const std::string& path) const {
   DCHECK(CalledOnValidThread());
-  const Value* default_value = NULL;
+  const base::Value* default_value = NULL;
   if (pref_registry_->defaults()->GetValue(path, &default_value)) {
-    const Value* found_value = NULL;
+    const base::Value* found_value = NULL;
     base::Value::Type default_type = default_value->GetType();
     if (pref_value_store_->GetValue(path, default_type, &found_value)) {
       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;
 }