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

chrome/browser/extensions/api/content_settings/content_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.
 
 #include "chrome/browser/extensions/api/content_settings/content_settings_api.h"
 
 #include <set>
 #include <vector>
 
 #include "base/bind.h"
@@ skipping 24 matching lines @@
 namespace Clear = extensions::api::content_settings::ContentSetting::Clear;
 namespace Get = extensions::api::content_settings::ContentSetting::Get;
 namespace Set = extensions::api::content_settings::ContentSetting::Set;
 namespace pref_helpers = extensions::preference_helpers;
 namespace pref_keys = extensions::preference_api_constants;
 
 namespace {
 
 const std::vector<webkit::WebPluginInfo>* g_testing_plugins_;
 
-bool RemoveContentType(ListValue* args, ContentSettingsType* content_type) {
+bool RemoveContentType(base::ListValue* args,
+                       ContentSettingsType* content_type) {
   std::string content_type_str;
   if (!args->GetString(0, &content_type_str))
     return false;
   // We remove the ContentSettingsType parameter since this is added by the
   // renderer, and is not part of the JSON schema.
   args->Remove(0, NULL);
   *content_type =
       extensions::content_settings_helpers::StringToContentSettingsType(
           content_type_str);
   return *content_type != CONTENT_SETTINGS_TYPE_DEFAULT;
@@ skipping 97 matching lines @@
   if (content_type == CONTENT_SETTINGS_TYPE_COOKIES) {
     // TODO(jochen): Do we return the value for setting or for reading cookies?
     bool setting_cookie = false;
     setting = cookie_settings->GetCookieSetting(primary_url, secondary_url,
                                                 setting_cookie, NULL);
   } else {
     setting = map->GetContentSetting(primary_url, secondary_url, content_type,
                                      resource_identifier);
   }
 
-  DictionaryValue* result = new DictionaryValue();
+  base::DictionaryValue* result = new base::DictionaryValue();
   result->SetString(keys::kContentSettingKey,
                     helpers::ContentSettingToString(setting));
 
   SetResult(result);
 
   return true;
 }
 
 bool ContentSettingsContentSettingSetFunction::RunImpl() {
   ContentSettingsType content_type;
@@ skipping 93 matching lines @@
   } else {
     OnGotPlugins(*g_testing_plugins_);
   }
   return true;
 }
 
 void ContentSettingsContentSettingGetResourceIdentifiersFunction::OnGotPlugins(
     const std::vector<webkit::WebPluginInfo>& plugins) {
   PluginFinder* finder = PluginFinder::GetInstance();
   std::set<std::string> group_identifiers;
-  ListValue* list = new ListValue();
+  base::ListValue* list = new base::ListValue();
   for (std::vector<webkit::WebPluginInfo>::const_iterator it = plugins.begin();
        it != plugins.end(); ++it) {
     scoped_ptr<PluginMetadata> plugin_metadata(finder->GetPluginMetadata(*it));
     const std::string& group_identifier = plugin_metadata->identifier();
     if (group_identifiers.find(group_identifier) != group_identifiers.end())
       continue;
 
     group_identifiers.insert(group_identifier);
-    DictionaryValue* dict = new DictionaryValue();
+    base::DictionaryValue* dict = new base::DictionaryValue();
     dict->SetString(keys::kIdKey, group_identifier);
     dict->SetString(keys::kDescriptionKey, plugin_metadata->name());
     list->Append(dict);
   }
   SetResult(list);
   BrowserThread::PostTask(
       BrowserThread::UI, FROM_HERE, base::Bind(
           &ContentSettingsContentSettingGetResourceIdentifiersFunction::
           SendResponse,
           this,
           true));
 }
 
 // static
 void ContentSettingsContentSettingGetResourceIdentifiersFunction::
     SetPluginsForTesting(const std::vector<webkit::WebPluginInfo>* plugins) {
   g_testing_plugins_ = plugins;
 }
 
 }  // namespace extensions