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

chrome/browser/chromeos/input_method/component_extension_ime_manager_impl.cc

 // Copyright 2013 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/chromeos/input_method/component_extension_ime_manager_impl.h"
 
 #include "base/file_util.h"
 #include "base/logging.h"
 #include "chrome/browser/extensions/component_loader.h"
 #include "chrome/browser/extensions/extension_service.h"
@@ skipping 117 matching lines @@
 bool ComponentExtensionIMEManagerImpl::Unload(const std::string& extension_id,
                                               const base::FilePath& file_path) {
   DCHECK(thread_checker_.CalledOnValidThread());
   if (loaded_extension_id_.find(extension_id) == loaded_extension_id_.end())
     return false;
   GetComponentLoader()->Remove(extension_id);
   loaded_extension_id_.erase(extension_id);
   return true;
 }
 
-scoped_ptr<DictionaryValue> ComponentExtensionIMEManagerImpl::GetManifest(
+scoped_ptr<base::DictionaryValue> ComponentExtensionIMEManagerImpl::GetManifest(
     const base::FilePath& file_path) {
   DCHECK(content::BrowserThread::CurrentlyOn(content::BrowserThread::FILE));
   std::string error;
-  scoped_ptr<DictionaryValue> manifest(
+  scoped_ptr<base::DictionaryValue> manifest(
       extension_file_util::LoadManifest(file_path, &error));
   if (!manifest.get())
     LOG(ERROR) << "Failed at getting manifest";
   if (!extension_l10n_util::LocalizeExtension(file_path,
                                               manifest.get(),
                                               &error))
     LOG(ERROR) << "Localization failed";
 
   return manifest.Pass();
 }
@@ skipping 16 matching lines @@
           base::Owned(component_extension_ime_list),
           callback));
 }
 
 bool ComponentExtensionIMEManagerImpl::IsInitialized() {
   return is_initialized_;
 }
 
 // static
 bool ComponentExtensionIMEManagerImpl::ReadEngineComponent(
-    const DictionaryValue& dict,
+    const base::DictionaryValue& dict,
     ComponentExtensionEngine* out) {
   DCHECK(content::BrowserThread::CurrentlyOn(content::BrowserThread::FILE));
   DCHECK(out);
   std::string type;
   if (!dict.GetString(extensions::manifest_keys::kType, &type))
     return false;
   if (type != "ime")
     return false;
   if (!dict.GetString(extensions::manifest_keys::kId, &out->engine_id))
     return false;
@@ skipping 13 matching lines @@
       for (size_t j = 0; j < language_list->GetSize(); ++j) {
         std::string language_str;
         if (language_list->GetString(j, &language_str))
           languages.insert(language_str);
       }
     }
   }
   DCHECK(!languages.empty());
   out->language_codes.assign(languages.begin(), languages.end());
 
-  const ListValue* layouts = NULL;
+  const base::ListValue* layouts = NULL;
   if (!dict.GetList(extensions::manifest_keys::kLayouts, &layouts))
     return false;
 
   for (size_t i = 0; i < layouts->GetSize(); ++i) {
     std::string buffer;
     if (layouts->GetString(i, &buffer))
       out->layouts.push_back(buffer);
   }
   return true;
 }
 
 // static
 bool ComponentExtensionIMEManagerImpl::ReadExtensionInfo(
-    const DictionaryValue& manifest,
+    const base::DictionaryValue& manifest,
     const std::string& extension_id,
     ComponentExtensionIME* out) {
   DCHECK(content::BrowserThread::CurrentlyOn(content::BrowserThread::FILE));
   if (!manifest.GetString(extensions::manifest_keys::kDescription,
                           &out->description))
     return false;
   std::string url_string;
   if (manifest.GetString(extensions::manifest_keys::kOptionsPage,
                          &url_string)) {
     GURL url = extensions::Extension::GetResourceURL(
@@ skipping 29 matching lines @@
     const base::FilePath manifest_path =
         component_ime.path.Append("manifest.json");
 
     if (!base::PathExists(component_ime.path) ||
         !base::PathExists(manifest_path))
       continue;
 
     if (!base::ReadFileToString(manifest_path, &component_ime.manifest))
       continue;
 
-    scoped_ptr<DictionaryValue> manifest = GetManifest(component_ime.path);
+    scoped_ptr<base::DictionaryValue> manifest =
+        GetManifest(component_ime.path);
     if (!manifest.get())
       continue;
 
     if (!ReadExtensionInfo(*manifest.get(),
                            whitelisted_component_extension[i].id,
                            &component_ime))
       continue;
     component_ime.id = whitelisted_component_extension[i].id;
 
-    const ListValue* component_list;
+    const base::ListValue* component_list;
     if (!manifest->GetList(extensions::manifest_keys::kInputComponents,
                            &component_list))
       continue;
 
     for (size_t i = 0; i < component_list->GetSize(); ++i) {
-      const DictionaryValue* dictionary;
+      const base::DictionaryValue* dictionary;
       if (!component_list->GetDictionary(i, &dictionary))
         continue;
 
       ComponentExtensionEngine engine;
       ReadEngineComponent(*dictionary, &engine);
       component_ime.engines.push_back(engine);
     }
     out_imes->push_back(component_ime);
   }
 }
 
 void ComponentExtensionIMEManagerImpl::OnReadComponentExtensionsInfo(
     std::vector<ComponentExtensionIME>* result,
     const base::Closure& callback) {
   DCHECK(thread_checker_.CalledOnValidThread());
   DCHECK(result);
   component_extension_list_ = *result;
   is_initialized_ = true;
   callback.Run();
 }
 
 }  // namespace chromeos