Add base namespace to more values in sync and elsewhere.

chrome/installer/util/master_preferences.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/installer/util/master_preferences.h"
 
 #include "base/environment.h"
 #include "base/file_util.h"
 #include "base/json/json_string_value_serializer.h"
 #include "base/lazy_instance.h"
 #include "base/logging.h"
 #include "base/path_service.h"
 #include "base/strings/string_util.h"
 #include "chrome/common/env_vars.h"
 #include "chrome/common/pref_names.h"
 #include "chrome/installer/util/master_preferences_constants.h"
 #include "chrome/installer/util/util_constants.h"
 
 namespace {
 
 const char kFirstRunTabs[] = "first_run_tabs";
 
 base::LazyInstance<installer::MasterPreferences> g_master_preferences =
     LAZY_INSTANCE_INITIALIZER;
 
-bool GetURLFromValue(const Value* in_value, std::string* out_value) {
+bool GetURLFromValue(const base::Value* in_value, std::string* out_value) {
   return in_value && out_value && in_value->GetAsString(out_value);
 }
 
 std::vector<std::string> GetNamedList(const char* name,
-                                      const DictionaryValue* prefs) {
+                                      const base::DictionaryValue* prefs) {
   std::vector<std::string> list;
   if (!prefs)
     return list;
 
-  const ListValue* value_list = NULL;
+  const base::ListValue* value_list = NULL;
   if (!prefs->GetList(name, &value_list))
     return list;
 
   list.reserve(value_list->GetSize());
   for (size_t i = 0; i < value_list->GetSize(); ++i) {
-    const Value* entry;
+    const base::Value* entry;
     std::string url_entry;
     if (!value_list->Get(i, &entry) || !GetURLFromValue(entry, &url_entry)) {
       NOTREACHED();
       break;
     }
     list.push_back(url_entry);
   }
   return list;
 }
 
-DictionaryValue* ParseDistributionPreferences(const std::string& json_data) {
+base::DictionaryValue* ParseDistributionPreferences(
+    const std::string& json_data) {
   JSONStringValueSerializer json(json_data);
   std::string error;
-  scoped_ptr<Value> root(json.Deserialize(NULL, &error));
+  scoped_ptr<base::Value> root(json.Deserialize(NULL, &error));
   if (!root.get()) {
     LOG(WARNING) << "Failed to parse master prefs file: " << error;
     return NULL;
   }
-  if (!root->IsType(Value::TYPE_DICTIONARY)) {
+  if (!root->IsType(base::Value::TYPE_DICTIONARY)) {
     LOG(WARNING) << "Failed to parse master prefs file: "
                  << "Root item must be a dictionary.";
     return NULL;
   }
-  return static_cast<DictionaryValue*>(root.release());
+  return static_cast<base::DictionaryValue*>(root.release());
 }
 
 }  // namespace
 
 namespace installer {
 
 MasterPreferences::MasterPreferences() : distribution_(NULL),
                                          preferences_read_from_file_(false),
                                          chrome_(true),
                                          chrome_app_launcher_(false),
@@ skipping 44 matching lines @@
 MasterPreferences::~MasterPreferences() {
 }
 
 void MasterPreferences::InitializeFromCommandLine(const CommandLine& cmd_line) {
 #if defined(OS_WIN)
   if (cmd_line.HasSwitch(installer::switches::kInstallerData)) {
     base::FilePath prefs_path(cmd_line.GetSwitchValuePath(
         installer::switches::kInstallerData));
     this->MasterPreferences::MasterPreferences(prefs_path);
   } else {
-    master_dictionary_.reset(new DictionaryValue());
+    master_dictionary_.reset(new base::DictionaryValue());
   }
 
   DCHECK(master_dictionary_.get());
 
   // A simple map from command line switches to equivalent switches in the
   // distribution dictionary.  Currently all switches added will be set to
   // 'true'.
   static const struct CmdLineSwitchToDistributionSwitch {
     const char* cmd_line_switch;
     const char* distribution_switch;
@@ skipping 67 matching lines @@
   InitializeProductFlags();
 #endif
 }
 
 bool MasterPreferences::InitializeFromString(const std::string& json_data) {
   if (!json_data.empty())
     master_dictionary_.reset(ParseDistributionPreferences(json_data));
 
   bool data_is_valid = true;
   if (!master_dictionary_.get()) {
-    master_dictionary_.reset(new DictionaryValue());
+    master_dictionary_.reset(new base::DictionaryValue());
     data_is_valid = false;
   } else {
     // Cache a pointer to the distribution dictionary.
     master_dictionary_->GetDictionary(
         installer::master_preferences::kDistroDict, &distribution_);
   }
 
   InitializeProductFlags();
   EnforceLegacyPreferences();
   return data_is_valid;
@@ skipping 68 matching lines @@
   bool ret = false;
   if (distribution_)
     ret = (distribution_->GetString(name, value) && !value->empty());
   return ret;
 }
 
 std::vector<std::string> MasterPreferences::GetFirstRunTabs() const {
   return GetNamedList(kFirstRunTabs, master_dictionary_.get());
 }
 
-bool MasterPreferences::GetExtensionsBlock(DictionaryValue** extensions) const {
+bool MasterPreferences::GetExtensionsBlock(
+    base::DictionaryValue** extensions) const {
   return master_dictionary_->GetDictionary(
       master_preferences::kExtensionsBlock, extensions);
 }
 
 std::string MasterPreferences::GetVariationsSeed() const {
   std::string variations_seed;
   master_dictionary_->GetString(prefs::kVariationsSeed, &variations_seed);
   return variations_seed;
 }
 
 // static
 const MasterPreferences& MasterPreferences::ForCurrentProcess() {
   return g_master_preferences.Get();
 }
 
 }  // namespace installer