Update some uses of Value in chrome/browser to use the base:: namespace.

chrome/browser/plugins/plugin_finder.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/plugins/plugin_finder.h"
 
 #include "base/bind.h"
 #include "base/json/json_reader.h"
 #include "base/message_loop/message_loop.h"
 #include "base/prefs/pref_registry_simple.h"
@@ skipping 35 matching lines @@
 // Gets the plug-in group name as the plug-in name if it is not empty or
 // the filename without extension if the name is empty.
 static base::string16 GetGroupName(const content::WebPluginInfo& plugin) {
   if (!plugin.name.empty())
     return plugin.name;
 
   return plugin.path.BaseName().RemoveExtension().AsUTF16Unsafe();
 }
 
 void LoadMimeTypes(bool matching_mime_types,
-                   const DictionaryValue* plugin_dict,
+                   const base::DictionaryValue* plugin_dict,
                    PluginMetadata* plugin) {
-  const ListValue* mime_types = NULL;
+  const base::ListValue* mime_types = NULL;
   std::string list_key =
       matching_mime_types ? "matching_mime_types" : "mime_types";
   if (!plugin_dict->GetList(list_key, &mime_types))
     return;
 
   bool success = false;
-  for (ListValue::const_iterator mime_type_it = mime_types->begin();
+  for (base::ListValue::const_iterator mime_type_it = mime_types->begin();
        mime_type_it != mime_types->end(); ++mime_type_it) {
     std::string mime_type_str;
     success = (*mime_type_it)->GetAsString(&mime_type_str);
     DCHECK(success);
     if (matching_mime_types) {
       plugin->AddMatchingMimeType(mime_type_str);
     } else {
       plugin->AddMimeType(mime_type_str);
     }
   }
 }
 
 PluginMetadata* CreatePluginMetadata(
     const std::string& identifier,
-    const DictionaryValue* plugin_dict) {
+    const base::DictionaryValue* plugin_dict) {
   std::string url;
   bool success = plugin_dict->GetString("url", &url);
   std::string help_url;
   plugin_dict->GetString("help_url", &help_url);
   base::string16 name;
   success = plugin_dict->GetString("name", &name);
   DCHECK(success);
   bool display_url = false;
   plugin_dict->GetBoolean("displayurl", &display_url);
   base::string16 group_name_matcher;
   success = plugin_dict->GetString("group_name_matcher", &group_name_matcher);
   DCHECK(success);
   std::string language_str;
   plugin_dict->GetString("lang", &language_str);
 
   PluginMetadata* plugin = new PluginMetadata(identifier,
                                               name,
                                               display_url,
                                               GURL(url),
                                               GURL(help_url),
                                               group_name_matcher,
                                               language_str);
-  const ListValue* versions = NULL;
+  const base::ListValue* versions = NULL;
   if (plugin_dict->GetList("versions", &versions)) {
-    for (ListValue::const_iterator it = versions->begin();
+    for (base::ListValue::const_iterator it = versions->begin();
          it != versions->end(); ++it) {
-      DictionaryValue* version_dict = NULL;
+      base::DictionaryValue* version_dict = NULL;
       if (!(*it)->GetAsDictionary(&version_dict)) {
         NOTREACHED();
         continue;
       }
       std::string version;
       success = version_dict->GetString("version", &version);
       DCHECK(success);
       std::string status_str;
       success = version_dict->GetString("status", &status_str);
       DCHECK(success);
@@ skipping 25 matching lines @@
 }
 
 PluginFinder::PluginFinder() : version_(-1) {
   DCHECK(content::BrowserThread::CurrentlyOn(content::BrowserThread::UI));
 }
 
 void PluginFinder::Init() {
   DCHECK(content::BrowserThread::CurrentlyOn(content::BrowserThread::UI));
   // Load the built-in plug-in list first. If we have a newer version stored
   // locally or download one, we will replace this one with it.
-  scoped_ptr<DictionaryValue> plugin_list(LoadBuiltInPluginList());
+  scoped_ptr<base::DictionaryValue> plugin_list(LoadBuiltInPluginList());
   DCHECK(plugin_list);
   ReinitializePlugins(plugin_list.get());
 }
 
 // static
-DictionaryValue* PluginFinder::LoadBuiltInPluginList() {
+base::DictionaryValue* PluginFinder::LoadBuiltInPluginList() {
   base::StringPiece json_resource(
       ResourceBundle::GetSharedInstance().GetRawDataResource(
           IDR_PLUGIN_DB_JSON));
   std::string error_str;
   scoped_ptr<base::Value> value(base::JSONReader::ReadAndReturnError(
       json_resource,
       base::JSON_PARSE_RFC,
       NULL,
       &error_str));
   if (!value.get()) {
@@ skipping 66 matching lines @@
   const char kVersionKey[] = "x-version";
   plugin_list->GetInteger(kVersionKey, &version);
   if (version <= version_)
     return;
 
   version_ = version;
 
   STLDeleteValues(&identifier_plugin_);
   identifier_plugin_.clear();
 
-  for (DictionaryValue::Iterator plugin_it(*plugin_list);
+  for (base::DictionaryValue::Iterator plugin_it(*plugin_list);
       !plugin_it.IsAtEnd(); plugin_it.Advance()) {
-    const DictionaryValue* plugin = NULL;
+    const base::DictionaryValue* plugin = NULL;
     const std::string& identifier = plugin_it.key();
     if (plugin_list->GetDictionaryWithoutPathExpansion(identifier, &plugin)) {
       DCHECK(!identifier_plugin_[identifier]);
       identifier_plugin_[identifier] = CreatePluginMetadata(identifier, plugin);
 
 #if defined(ENABLE_PLUGIN_INSTALLATION)
       if (installers_.find(identifier) == installers_.end())
         installers_[identifier] = new PluginInstaller();
 #endif
     }
@@ skipping 36 matching lines @@
     metadata->AddMatchingMimeType(plugin.mime_types[i].mime_type);
 
   DCHECK(metadata->MatchesPlugin(plugin));
   if (identifier_plugin_.find(identifier) != identifier_plugin_.end())
     identifier = GetLongIdentifier(plugin);
 
   DCHECK(identifier_plugin_.find(identifier) == identifier_plugin_.end());
   identifier_plugin_[identifier] = metadata;
   return metadata->Clone();
 }