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

chrome/browser/about_flags.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/about_flags.h"
 
 #include <algorithm>
 #include <iterator>
 #include <map>
 #include <set>
@@ skipping 61 matching lines @@
 #define MULTI_VALUE_TYPE(choices) \
     Experiment::MULTI_VALUE, NULL, NULL, NULL, NULL, choices, arraysize(choices)
 
 namespace {
 
 const unsigned kOsAll = kOsMac | kOsWin | kOsLinux | kOsCrOS | kOsAndroid;
 const unsigned kOsDesktop = kOsMac | kOsWin | kOsLinux | kOsCrOS;
 
 // Adds a |StringValue| to |list| for each platform where |bitmask| indicates
 // whether the experiment is available on that platform.
-void AddOsStrings(unsigned bitmask, ListValue* list) {
+void AddOsStrings(unsigned bitmask, base::ListValue* list) {
   struct {
     unsigned bit;
     const char* const name;
   } kBitsToOs[] = {
     {kOsMac, "Mac"},
     {kOsWin, "Windows"},
     {kOsLinux, "Linux"},
     {kOsCrOS, "Chrome OS"},
     {kOsAndroid, "Android"},
     {kOsCrOSOwnerOnly, "Chrome OS (owner only)"},
   };
   for (size_t i = 0; i < ARRAYSIZE_UNSAFE(kBitsToOs); ++i)
     if (bitmask & kBitsToOs[i].bit)
-      list->Append(new StringValue(kBitsToOs[i].name));
+      list->Append(new base::StringValue(kBitsToOs[i].name));
 }
 
 // Convert switch constants to proper CommandLine::StringType strings.
 CommandLine::StringType GetSwitchString(const std::string& flag) {
   CommandLine cmd_line(CommandLine::NO_PROGRAM);
   cmd_line.AppendSwitch(flag);
   DCHECK(cmd_line.argv().size() == 2);
   return cmd_line.argv()[1];
 }
 
@@ skipping 1977 matching lines @@
   std::set<std::string> new_enabled_experiments;
   std::set_intersection(
       platform_experiments.begin(), platform_experiments.end(),
       result->begin(), result->end(),
       std::inserter(new_enabled_experiments, new_enabled_experiments.begin()));
 
   result->swap(new_enabled_experiments);
 }
 
 // Returns the Value representing the choice data in the specified experiment.
-Value* CreateChoiceData(const Experiment& experiment,
-                        const std::set<std::string>& enabled_experiments) {
+base::Value* CreateChoiceData(
+    const Experiment& experiment,
+    const std::set<std::string>& enabled_experiments) {
   DCHECK(experiment.type == Experiment::MULTI_VALUE ||
          experiment.type == Experiment::ENABLE_DISABLE_VALUE);
-  ListValue* result = new ListValue;
+  base::ListValue* result = new base::ListValue;
   for (int i = 0; i < experiment.num_choices; ++i) {
-    DictionaryValue* value = new DictionaryValue;
+    base::DictionaryValue* value = new base::DictionaryValue;
     const std::string name = experiment.NameForChoice(i);
     value->SetString("internal_name", name);
     value->SetString("description", experiment.DescriptionForChoice(i));
     value->SetBoolean("selected", enabled_experiments.count(name) > 0);
     result->Append(value);
   }
   return result;
 }
 
 }  // namespace
@@ skipping 53 matching lines @@
   std::set<std::string> enabled_experiments;
   GetSanitizedEnabledFlags(flags_storage, &enabled_experiments);
 
   int current_platform = GetCurrentPlatform();
 
   for (size_t i = 0; i < num_experiments; ++i) {
     const Experiment& experiment = experiments[i];
     if (SkipConditionalExperiment(experiment))
       continue;
 
-    DictionaryValue* data = new DictionaryValue();
+    base::DictionaryValue* data = new base::DictionaryValue();
     data->SetString("internal_name", experiment.internal_name);
     data->SetString("name",
                     l10n_util::GetStringUTF16(experiment.visible_name_id));
     data->SetString("description",
                     l10n_util::GetStringUTF16(
                         experiment.visible_description_id));
 
-    ListValue* supported_platforms = new ListValue();
+    base::ListValue* supported_platforms = new base::ListValue();
     AddOsStrings(experiment.supported_platforms, supported_platforms);
     data->Set("supported_platforms", supported_platforms);
 
     switch (experiment.type) {
       case Experiment::SINGLE_VALUE:
         data->SetBoolean(
             "enabled",
             enabled_experiments.count(experiment.internal_name) > 0);
         break;
       case Experiment::MULTI_VALUE:
@@ skipping 261 matching lines @@
 }
 
 const Experiment* GetExperiments(size_t* count) {
   *count = num_experiments;
   return experiments;
 }
 
 }  // namespace testing
 
 }  // namespace about_flags