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

chrome/browser/extensions/api/autotest_private/autotest_private_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/autotest_private/autotest_private_api.h"
 
 #include "base/strings/string_number_conversions.h"
 #include "chrome/browser/extensions/api/autotest_private/autotest_private_api_factory.h"
 #include "chrome/browser/extensions/extension_action_manager.h"
 #include "chrome/browser/extensions/extension_function_registry.h"
@@ skipping 11 matching lines @@
 #if defined(OS_CHROMEOS)
 #include "chrome/browser/chromeos/login/screen_locker.h"
 #include "chrome/browser/chromeos/login/user_manager.h"
 #include "chromeos/dbus/dbus_thread_manager.h"
 #include "chromeos/dbus/session_manager_client.h"
 #endif
 
 namespace extensions {
 namespace {
 
-ListValue* GetHostPermissions(const Extension* ext, bool effective_perm) {
+base::ListValue* GetHostPermissions(const Extension* ext, bool effective_perm) {
   extensions::URLPatternSet pattern_set;
   if (effective_perm) {
     pattern_set =
         extensions::PermissionsData::GetEffectiveHostPermissions(ext);
   } else {
     pattern_set = ext->GetActivePermissions()->explicit_hosts();
   }
 
-  ListValue* permissions = new ListValue;
+  base::ListValue* permissions = new base::ListValue;
   for (extensions::URLPatternSet::const_iterator perm = pattern_set.begin();
        perm != pattern_set.end(); ++perm) {
-    permissions->Append(new StringValue(perm->GetAsString()));
+    permissions->Append(new base::StringValue(perm->GetAsString()));
   }
 
   return permissions;
 }
 
-ListValue* GetAPIPermissions(const Extension* ext) {
-  ListValue* permissions = new ListValue;
+base::ListValue* GetAPIPermissions(const Extension* ext) {
+  base::ListValue* permissions = new base::ListValue;
   std::set<std::string> perm_list =
       ext->GetActivePermissions()->GetAPIsAsStrings();
   for (std::set<std::string>::const_iterator perm = perm_list.begin();
        perm != perm_list.end(); ++perm) {
-    permissions->Append(new StringValue(perm->c_str()));
+    permissions->Append(new base::StringValue(perm->c_str()));
   }
   return permissions;
 }
 
 }  // namespace
 
 bool AutotestPrivateLogoutFunction::RunImpl() {
   DVLOG(1) << "AutotestPrivateLogoutFunction";
   if (!AutotestPrivateAPIFactory::GetForProfile(GetProfile())->test_mode())
     chrome::AttemptUserExit();
@@ skipping 84 matching lines @@
 bool AutotestPrivateGetExtensionsInfoFunction::RunImpl() {
   DVLOG(1) << "AutotestPrivateGetExtensionsInfoFunction";
 
   ExtensionService* service = extensions::ExtensionSystem::Get(
       GetProfile())->extension_service();
   const ExtensionSet* extensions = service->extensions();
   const ExtensionSet* disabled_extensions = service->disabled_extensions();
   ExtensionActionManager* extension_action_manager =
       ExtensionActionManager::Get(GetProfile());
 
-  ListValue* extensions_values = new ListValue;
+  base::ListValue* extensions_values = new base::ListValue;
   ExtensionList all;
   all.insert(all.end(),
              extensions->begin(),
              extensions->end());
   all.insert(all.end(),
              disabled_extensions->begin(),
              disabled_extensions->end());
   for (ExtensionList::const_iterator it = all.begin();
        it != all.end(); ++it) {
     const Extension* extension = it->get();
     std::string id = extension->id();
-    DictionaryValue* extension_value = new DictionaryValue;
+    base::DictionaryValue* extension_value = new base::DictionaryValue;
     extension_value->SetString("id", id);
     extension_value->SetString("version", extension->VersionString());
     extension_value->SetString("name", extension->name());
     extension_value->SetString("publicKey", extension->public_key());
     extension_value->SetString("description", extension->description());
     extension_value->SetString("backgroundUrl",
         extensions::BackgroundInfo::GetBackgroundURL(extension).spec());
     extension_value->SetString("optionsUrl",
         extensions::ManifestURL::GetOptionsPage(extension).spec());
 
@@ skipping 14 matching lines @@
     extension_value->SetBoolean("isEnabled", service->IsExtensionEnabled(id));
     extension_value->SetBoolean("allowedInIncognito",
         extension_util::IsIncognitoEnabled(id, service));
     extension_value->SetBoolean(
         "hasPageAction",
         extension_action_manager->GetPageAction(*extension) != NULL);
 
     extensions_values->Append(extension_value);
   }
 
-  DictionaryValue* return_value(new DictionaryValue);
+  base::DictionaryValue* return_value(new base::DictionaryValue);
   return_value->Set("extensions", extensions_values);
   SetResult(return_value);
   return true;
 }
 
 static int AccessArray(const volatile int arr[], const volatile int *index) {
   return arr[*index];
 }
 
 bool AutotestPrivateSimulateAsanMemoryBugFunction::RunImpl() {
@@ skipping 10 matching lines @@
 }
 
 
 AutotestPrivateAPI::AutotestPrivateAPI() : test_mode_(false) {
 }
 
 AutotestPrivateAPI::~AutotestPrivateAPI() {
 }
 
 }  // namespace extensions