Remove the Value class names from the global namespace.

chrome/browser/extensions/external_pref_loader.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/external_pref_loader.h"
 
 #include "base/bind.h"
 #include "base/file_util.h"
 #include "base/files/file_enumerator.h"
 #include "base/files/file_path.h"
@@ skipping 49 matching lines @@
   } while (true);
 
   return external_extension_paths;
 }
 
 // Extracts extension information from a json file serialized by |serializer|.
 // |path| is only used for informational purposes (outputted when an error
 // occurs). An empty dictionary is returned in case of failure (e.g. invalid
 // path or json content).
 // Caller takes ownership of the returned dictionary.
-DictionaryValue* ExtractExtensionPrefs(base::ValueSerializer* serializer,
-                                       const base::FilePath& path) {
+base::DictionaryValue* ExtractExtensionPrefs(base::ValueSerializer* serializer,
+                                             const base::FilePath& path) {
   std::string error_msg;
-  Value* extensions = serializer->Deserialize(NULL, &error_msg);
+  base::Value* extensions = serializer->Deserialize(NULL, &error_msg);
   if (!extensions) {
     LOG(WARNING) << "Unable to deserialize json data: " << error_msg
                  << " in file " << path.value() << ".";
-    return new DictionaryValue;
+    return new base::DictionaryValue;
   }
 
-  DictionaryValue* ext_dictionary = NULL;
+  base::DictionaryValue* ext_dictionary = NULL;
   if (extensions->GetAsDictionary(&ext_dictionary))
     return ext_dictionary;
 
   LOG(WARNING) << "Expected a JSON dictionary in file "
                << path.value() << ".";
-  return new DictionaryValue;
+  return new base::DictionaryValue;
 }
 
 }  // namespace
 
 namespace extensions {
 
 ExternalPrefLoader::ExternalPrefLoader(int base_path_id, Options options)
     : base_path_id_(base_path_id), options_(options) {
   CHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 }
 
 const base::FilePath ExternalPrefLoader::GetBaseCrxFilePath() {
   CHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
   // |base_path_| was set in LoadOnFileThread().
   return base_path_;
 }
 
 void ExternalPrefLoader::StartLoading() {
   CHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   BrowserThread::PostTask(
       BrowserThread::FILE, FROM_HERE,
       base::Bind(&ExternalPrefLoader::LoadOnFileThread, this));
 }
 
 void ExternalPrefLoader::LoadOnFileThread() {
   CHECK(BrowserThread::CurrentlyOn(BrowserThread::FILE));
 
-  scoped_ptr<DictionaryValue> prefs(new DictionaryValue);
+  scoped_ptr<base::DictionaryValue> prefs(new base::DictionaryValue);
 
   // TODO(skerner): Some values of base_path_id_ will cause
   // PathService::Get() to return false, because the path does
   // not exist.  Find and fix the build/install scripts so that
   // this can become a CHECK().  Known examples include chrome
   // OS developer builds and linux install packages.
   // Tracked as crbug.com/70402 .
   if (PathService::Get(base_path_id_, &base_path_)) {
     ReadExternalExtensionPrefFile(prefs.get());
 
@@ skipping 17 matching lines @@
   // read at least one .json file.  If so, then we should have
   // set |base_path_|.
   if (!prefs_->empty())
     CHECK(!base_path_.empty());
 
   BrowserThread::PostTask(
       BrowserThread::UI, FROM_HERE,
       base::Bind(&ExternalPrefLoader::LoadFinished, this));
 }
 
-void ExternalPrefLoader::ReadExternalExtensionPrefFile(DictionaryValue* prefs) {
+void ExternalPrefLoader::ReadExternalExtensionPrefFile(
+    base::DictionaryValue* prefs) {
   CHECK(BrowserThread::CurrentlyOn(BrowserThread::FILE));
   CHECK(NULL != prefs);
 
   base::FilePath json_file = base_path_.Append(kExternalExtensionJson);
 
   if (!base::PathExists(json_file)) {
     // This is not an error.  The file does not exist by default.
     return;
   }
 
@@ skipping 10 matching lines @@
     }
 #else
     // The only platform that uses this check is Mac OS.  If you add one,
     // you need to implement file_util::VerifyPathControlledByAdmin() for
     // that platform.
     NOTREACHED();
 #endif  // defined(OS_MACOSX)
   }
 
   JSONFileValueSerializer serializer(json_file);
-  scoped_ptr<DictionaryValue> ext_prefs(
+  scoped_ptr<base::DictionaryValue> ext_prefs(
       ExtractExtensionPrefs(&serializer, json_file));
   if (ext_prefs)
     prefs->MergeDictionary(ext_prefs.get());
 }
 
 void ExternalPrefLoader::ReadStandaloneExtensionPrefFiles(
-    DictionaryValue* prefs) {
+    base::DictionaryValue* prefs) {
   CHECK(BrowserThread::CurrentlyOn(BrowserThread::FILE));
   CHECK(NULL != prefs);
 
   // First list the potential .json candidates.
   std::set<base::FilePath>
       candidates = GetPrefsCandidateFilesFromFolder(base_path_);
   if (candidates.empty()) {
     DVLOG(1) << "Extension candidates list empty";
     return;
   }
@@ skipping 10 matching lines @@
         WideToASCII(
             extension_candidate_path.RemoveExtension().BaseName().value());
 #elif defined(OS_POSIX)
         extension_candidate_path.RemoveExtension().BaseName().value().c_str();
 #endif
 
     DVLOG(1) << "Reading json file: "
              << extension_candidate_path.LossyDisplayName().c_str();
 
     JSONFileValueSerializer serializer(extension_candidate_path);
-    scoped_ptr<DictionaryValue> ext_prefs(
+    scoped_ptr<base::DictionaryValue> ext_prefs(
         ExtractExtensionPrefs(&serializer, extension_candidate_path));
     if (ext_prefs) {
       DVLOG(1) << "Adding extension with id: " << id;
       prefs->Set(id, ext_prefs.release());
     }
   }
 }
 
 ExternalTestingLoader::ExternalTestingLoader(
     const std::string& json_data,
@@ skipping 11 matching lines @@
   LoadFinished();
 }
 
 ExternalTestingLoader::~ExternalTestingLoader() {}
 
 const base::FilePath ExternalTestingLoader::GetBaseCrxFilePath() {
   return fake_base_path_;
 }
 
 }  // extensions