Convert most of extensions and some other random stuff to using the base namespace for Values.

chrome/browser/extensions/api/font_settings/font_settings_api.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.
 
 // Font Settings Extension API implementation.
 
 #include "chrome/browser/extensions/api/font_settings/font_settings_api.h"
 
 #include "base/bind.h"
 #include "base/command_line.h"
@@ skipping 156 matching lines @@
       pref_name.c_str());
   CHECK(pref);
 
   std::string font_name;
   if (!pref->GetValue()->GetAsString(&font_name)) {
     NOTREACHED();
     return;
   }
   font_name = MaybeGetLocalizedFontName(font_name);
 
-  ListValue args;
-  DictionaryValue* dict = new DictionaryValue();
+  base::ListValue args;
+  base::DictionaryValue* dict = new base::DictionaryValue();
   args.Append(dict);
   dict->SetString(kFontIdKey, font_name);
   dict->SetString(kGenericFamilyKey, generic_family);
   dict->SetString(kScriptKey, script);
 
   extensions::preference_helpers::DispatchEventToExtensions(
       profile_,
       kOnFontChanged,
       &args,
       APIPermission::kFontSettings,
       false,
       pref_name);
 }
 
 void FontSettingsEventRouter::OnFontPrefChanged(
     const std::string& event_name,
     const std::string& key,
     const std::string& pref_name) {
   const PrefService::Preference* pref = registrar_.prefs()->FindPreference(
       pref_name.c_str());
   CHECK(pref);
 
-  ListValue args;
-  DictionaryValue* dict = new DictionaryValue();
+  base::ListValue args;
+  base::DictionaryValue* dict = new base::DictionaryValue();
   args.Append(dict);
   dict->Set(key, pref->GetValue()->DeepCopy());
 
   extensions::preference_helpers::DispatchEventToExtensions(
       profile_,
       event_name,
       &args,
       APIPermission::kFontSettings,
       false,
       pref_name);
@@ skipping 55 matching lines @@
 
   // We don't support incognito-specific font prefs, so don't consider them when
   // getting level of control.
   const bool kIncognito = false;
   std::string level_of_control =
       extensions::preference_helpers::GetLevelOfControl(profile_,
                                                         extension_id(),
                                                         pref_path,
                                                         kIncognito);
 
-  DictionaryValue* result = new DictionaryValue();
+  base::DictionaryValue* result = new base::DictionaryValue();
   result->SetString(kFontIdKey, font_name);
   result->SetString(kLevelOfControlKey, level_of_control);
   SetResult(result);
   return true;
 }
 
 bool FontSettingsSetFontFunction::RunImpl() {
   if (profile_->IsOffTheRecord()) {
     error_ = kSetFromIncognitoError;
     return false;
@@ skipping 18 matching lines @@
   return true;
 }
 
 bool FontSettingsGetFontListFunction::RunImpl() {
   content::GetFontListAsync(
       Bind(&FontSettingsGetFontListFunction::FontListHasLoaded, this));
   return true;
 }
 
 void FontSettingsGetFontListFunction::FontListHasLoaded(
-    scoped_ptr<ListValue> list) {
+    scoped_ptr<base::ListValue> list) {
   bool success = CopyFontsToResult(list.get());
   SendResponse(success);
 }
 
-bool FontSettingsGetFontListFunction::CopyFontsToResult(ListValue* fonts) {
-  scoped_ptr<ListValue> result(new ListValue());
-  for (ListValue::iterator it = fonts->begin(); it != fonts->end(); ++it) {
-    ListValue* font_list_value;
+bool FontSettingsGetFontListFunction::CopyFontsToResult(
+    base::ListValue* fonts) {
+  scoped_ptr<base::ListValue> result(new base::ListValue());
+  for (base::ListValue::iterator it = fonts->begin();
+       it != fonts->end(); ++it) {
+    base::ListValue* font_list_value;
     if (!(*it)->GetAsList(&font_list_value)) {
       NOTREACHED();
       return false;
     }
 
     std::string name;
     if (!font_list_value->GetString(0, &name)) {
       NOTREACHED();
       return false;
     }
 
     std::string localized_name;
     if (!font_list_value->GetString(1, &localized_name)) {
       NOTREACHED();
       return false;
     }
 
-    DictionaryValue* font_name = new DictionaryValue();
+    base::DictionaryValue* font_name = new base::DictionaryValue();
     font_name->Set(kFontIdKey, Value::CreateStringValue(name));
     font_name->Set(kDisplayNameKey, Value::CreateStringValue(localized_name));
     result->Append(font_name);
   }
 
   SetResult(result.release());
   return true;
 }
 
 bool ClearFontPrefExtensionFunction::RunImpl() {
@@ skipping 15 matching lines @@
   // We don't support incognito-specific font prefs, so don't consider them when
   // getting level of control.
   const bool kIncognito = false;
 
   std::string level_of_control =
       extensions::preference_helpers::GetLevelOfControl(profile_,
                                                         extension_id(),
                                                         GetPrefName(),
                                                         kIncognito);
 
-  DictionaryValue* result = new DictionaryValue();
+  base::DictionaryValue* result = new base::DictionaryValue();
   result->Set(GetKey(), pref->GetValue()->DeepCopy());
   result->SetString(kLevelOfControlKey, level_of_control);
   SetResult(result);
   return true;
 }
 
 bool SetFontPrefExtensionFunction::RunImpl() {
   if (profile_->IsOffTheRecord()) {
     error_ = kSetFromIncognitoError;
     return false;
   }
 
-  DictionaryValue* details = NULL;
+  base::DictionaryValue* details = NULL;
   EXTENSION_FUNCTION_VALIDATE(args_->GetDictionary(0, &details));
 
   Value* value;
   EXTENSION_FUNCTION_VALIDATE(details->Get(GetKey(), &value));
 
   PreferenceAPI::Get(profile_)->SetExtensionControlledPref(
       extension_id(),
       GetPrefName(),
       kExtensionPrefsScopeRegular,
       value->DeepCopy());
@@ skipping 54 matching lines @@
 
 const char* FontSettingsSetMinimumFontSizeFunction::GetPrefName() {
   return prefs::kWebKitMinimumFontSize;
 }
 
 const char* FontSettingsSetMinimumFontSizeFunction::GetKey() {
   return kPixelSizeKey;
 }
 
 }  // namespace extensions