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

chrome/browser/extensions/api/webstore_private/webstore_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/webstore_private/webstore_private_api.h"
 
 #include "apps/app_launcher.h"
 #include "base/bind_helpers.h"
 #include "base/command_line.h"
 #include "base/lazy_instance.h"
@@ skipping 150 matching lines @@
     "You cannot specify both icon data and an icon url";
 const char kInvalidIconUrlError[] = "Invalid icon url";
 const char kInvalidIdError[] = "Invalid id";
 const char kInvalidManifestError[] = "Invalid manifest";
 const char kNoPreviousBeginInstallWithManifestError[] =
     "* does not match a previous call to beginInstallWithManifest3";
 const char kUserCancelledError[] = "User cancelled install";
 
 // Helper to create a dictionary with login properties set from the appropriate
 // values in the passed-in |profile|.
-DictionaryValue* CreateLoginResult(Profile* profile) {
-  DictionaryValue* dictionary = new DictionaryValue();
+base::DictionaryValue* CreateLoginResult(Profile* profile) {
+  base::DictionaryValue* dictionary = new base::DictionaryValue();
   std::string username = profile->GetPrefs()->GetString(
       prefs::kGoogleServicesUsername);
   dictionary->SetString(kLoginKey, username);
   return dictionary;
 }
 
 WebstoreInstaller::Delegate* test_webstore_installer_delegate = NULL;
 
 void EnableAppLauncher(base::Callback<void(bool)> callback) {
 #if defined(OS_WIN)
@@ skipping 32 matching lines @@
 scoped_ptr<WebstoreInstaller::Approval>
 WebstorePrivateApi::PopApprovalForTesting(
     Profile* profile, const std::string& extension_id) {
   return g_pending_approvals.Get().PopApproval(profile, extension_id);
 }
 
 InstallBundleFunction::InstallBundleFunction() {}
 InstallBundleFunction::~InstallBundleFunction() {}
 
 bool InstallBundleFunction::RunImpl() {
-  ListValue* extensions = NULL;
+  base::ListValue* extensions = NULL;
   EXTENSION_FUNCTION_VALIDATE(args_->GetList(0, &extensions));
 
   BundleInstaller::ItemList items;
   if (!ReadBundleInfo(extensions, &items))
     return false;
 
   bundle_ = new BundleInstaller(GetCurrentBrowser(), items);
 
   AddRef();  // Balanced in OnBundleInstallCompleted / OnBundleInstallCanceled.
 
   bundle_->PromptForApproval(this);
   return true;
 }
 
-bool InstallBundleFunction::ReadBundleInfo(ListValue* extensions,
+bool InstallBundleFunction::ReadBundleInfo(base::ListValue* extensions,
                                            BundleInstaller::ItemList* items) {
   for (size_t i = 0; i < extensions->GetSize(); ++i) {
-    DictionaryValue* details = NULL;
+    base::DictionaryValue* details = NULL;
     EXTENSION_FUNCTION_VALIDATE(extensions->GetDictionary(i, &details));
 
     BundleInstaller::Item item;
     EXTENSION_FUNCTION_VALIDATE(details->GetString(
         kIdKey, &item.id));
     EXTENSION_FUNCTION_VALIDATE(details->GetString(
         kManifestKey, &item.manifest));
     EXTENSION_FUNCTION_VALIDATE(details->GetString(
         kLocalizedNameKey, &item.localized_name));
 
@@ skipping 25 matching lines @@
 
   Release();  // Balanced in RunImpl().
 }
 
 BeginInstallWithManifestFunction::BeginInstallWithManifestFunction()
     : use_app_installed_bubble_(false), enable_launcher_(false) {}
 
 BeginInstallWithManifestFunction::~BeginInstallWithManifestFunction() {}
 
 bool BeginInstallWithManifestFunction::RunImpl() {
-  DictionaryValue* details = NULL;
+  base::DictionaryValue* details = NULL;
   EXTENSION_FUNCTION_VALIDATE(args_->GetDictionary(0, &details));
   CHECK(details);
 
   EXTENSION_FUNCTION_VALIDATE(details->GetString(kIdKey, &id_));
   if (!extensions::Extension::IdIsValid(id_)) {
     SetResultCode(INVALID_ID);
     error_ = kInvalidIdError;
     return false;
   }
 
@@ skipping 94 matching lines @@
       SetResult(Value::CreateStringValue("already_installed"));
       break;
     default:
       CHECK(false);
   }
 }
 
 void BeginInstallWithManifestFunction::OnWebstoreParseSuccess(
     const std::string& id,
     const SkBitmap& icon,
-    DictionaryValue* parsed_manifest) {
+    base::DictionaryValue* parsed_manifest) {
   CHECK_EQ(id_, id);
   CHECK(parsed_manifest);
   icon_ = icon;
   parsed_manifest_.reset(parsed_manifest);
 
   std::string error;
   dummy_extension_ = ExtensionInstallPrompt::GetLocalizedExtensionForDisplay(
       parsed_manifest_.get(),
       Extension::FROM_WEBSTORE,
       id,
@@ skipping 293 matching lines @@
   SendResponse(true);
 }
 
 bool GetIsLauncherEnabledFunction::RunImpl() {
   SetResult(Value::CreateBooleanValue(apps::IsAppLauncherEnabled()));
   SendResponse(true);
   return true;
 }
 
 }  // namespace extensions