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

chrome/browser/extensions/sandboxed_unpacker.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/sandboxed_unpacker.h"
 
 #include <set>
 
 #include "base/base64.h"
 #include "base/bind.h"
@@ skipping 336 matching lines @@
       UtilityProcessHost::Create(this, unpacker_io_task_runner_.get());
   // Grant the subprocess access to the entire subdir the extension file is
   // in, so that it can unpack to that dir.
   host->SetExposedDir(temp_crx_path.DirName());
   host->Send(
       new ChromeUtilityMsg_UnpackExtension(
           temp_crx_path, extension_id_, location_, creation_flags_));
 }
 
 void SandboxedUnpacker::OnUnpackExtensionSucceeded(
-    const DictionaryValue& manifest) {
+    const base::DictionaryValue& manifest) {
   CHECK(unpacker_io_task_runner_->RunsTasksOnCurrentThread());
   got_response_ = true;
 
-  scoped_ptr<DictionaryValue> final_manifest(RewriteManifestFile(manifest));
+  scoped_ptr<base::DictionaryValue> final_manifest(
+      RewriteManifestFile(manifest));
   if (!final_manifest)
     return;
 
   // Create an extension object that refers to the temporary location the
   // extension was unpacked to. We use this until the extension is finally
   // installed. For example, the install UI shows images from inside the
   // extension.
 
   // Localize manifest now, so confirm UI gets correct extension name.
 
@@ skipping 210 matching lines @@
                                       const base::string16& error) {
   UMA_HISTOGRAM_ENUMERATION("Extensions.SandboxUnpackFailureReason",
                             reason, NUM_FAILURE_REASONS);
   UMA_HISTOGRAM_TIMES("Extensions.SandboxUnpackFailureTime",
                       base::TimeTicks::Now() - unpack_start_time_);
   Cleanup();
   client_->OnUnpackFailure(error);
 }
 
 void SandboxedUnpacker::ReportSuccess(
-    const DictionaryValue& original_manifest,
+    const base::DictionaryValue& original_manifest,
     const SkBitmap& install_icon) {
   UMA_HISTOGRAM_COUNTS("Extensions.SandboxUnpackSuccess", 1);
 
   RecordSuccessfulUnpackTimeHistograms(
       crx_path_, base::TimeTicks::Now() - unpack_start_time_);
 
   // Client takes ownership of temporary directory and extension.
   client_->OnUnpackSuccess(
       temp_dir_.Take(), extension_root_, &original_manifest, extension_.get(),
       install_icon);
   extension_ = NULL;
 }
 
-DictionaryValue* SandboxedUnpacker::RewriteManifestFile(
-    const DictionaryValue& manifest) {
+base::DictionaryValue* SandboxedUnpacker::RewriteManifestFile(
+    const base::DictionaryValue& manifest) {
   // Add the public key extracted earlier to the parsed manifest and overwrite
   // the original manifest. We do this to ensure the manifest doesn't contain an
   // exploitable bug that could be used to compromise the browser.
-  scoped_ptr<DictionaryValue> final_manifest(manifest.DeepCopy());
+  scoped_ptr<base::DictionaryValue> final_manifest(manifest.DeepCopy());
   final_manifest->SetString(manifest_keys::kPublicKey, public_key_);
 
   std::string manifest_json;
   JSONStringValueSerializer serializer(&manifest_json);
   serializer.set_pretty_print(true);
   if (!serializer.Serialize(*final_manifest)) {
     // Error serializing manifest.json.
     ReportFailure(
         ERROR_SERIALIZING_MANIFEST_JSON,
         l10n_util::GetStringFUTF16(
@@ skipping 126 matching lines @@
               IDS_EXTENSION_PACKAGE_INSTALL_ERROR,
               ASCIIToUTF16("ERROR_SAVING_THEME_IMAGE")));
       return false;
     }
   }
 
   return true;
 }
 
 bool SandboxedUnpacker::RewriteCatalogFiles() {
-  DictionaryValue catalogs;
+  base::DictionaryValue catalogs;
   if (!ReadMessageCatalogsFromFile(temp_dir_.path(), &catalogs)) {
     // Could not read catalog data from disk.
     ReportFailure(
         COULD_NOT_READ_CATALOG_DATA_FROM_DISK,
         l10n_util::GetStringFUTF16(
             IDS_EXTENSION_PACKAGE_INSTALL_ERROR,
             ASCIIToUTF16("COULD_NOT_READ_CATALOG_DATA_FROM_DISK")));
     return false;
   }
 
   // Write our parsed catalogs back to disk.
-  for (DictionaryValue::Iterator it(catalogs); !it.IsAtEnd(); it.Advance()) {
-    const DictionaryValue* catalog = NULL;
+  for (base::DictionaryValue::Iterator it(catalogs);
+       !it.IsAtEnd(); it.Advance()) {
+    const base::DictionaryValue* catalog = NULL;
     if (!it.value().GetAsDictionary(&catalog)) {
       // Invalid catalog data.
       ReportFailure(
           INVALID_CATALOG_DATA,
           l10n_util::GetStringFUTF16(
               IDS_EXTENSION_PACKAGE_INSTALL_ERROR,
               ASCIIToUTF16("INVALID_CATALOG_DATA")));
       return false;
     }
 
@@ skipping 42 matching lines @@
 
 void SandboxedUnpacker::Cleanup() {
   DCHECK(unpacker_io_task_runner_->RunsTasksOnCurrentThread());
   if (!temp_dir_.Delete()) {
     LOG(WARNING) << "Can not delete temp directory at "
                  << temp_dir_.path().value();
   }
 }
 
 }  // namespace extensions