Update uses of Value in chromeos/, cloud_print/, components/, content/ to use the base:: namespace.

components/policy/core/browser/configuration_policy_handler.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 "components/policy/core/browser/configuration_policy_handler.h"
 
 #include <algorithm>
 
 #include "base/callback.h"
 #include "base/files/file_path.h"
 #include "base/logging.h"
 #include "base/prefs/pref_value_map.h"
 #include "base/strings/string16.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/string_util.h"
 #include "components/policy/core/browser/configuration_policy_pref_store.h"
 #include "components/policy/core/browser/policy_error_map.h"
 #include "components/policy/core/common/policy_map.h"
 #include "grit/component_strings.h"
 #include "url/gurl.h"
 
 namespace policy {
 
 // ConfigurationPolicyHandler implementation -----------------------------------
 
 // static
-std::string ConfigurationPolicyHandler::ValueTypeToString(Value::Type type) {
+std::string ConfigurationPolicyHandler::ValueTypeToString(
+    base::Value::Type type) {
   static const char* strings[] = {
     "null",
     "boolean",
     "integer",
     "double",
     "string",
     "binary",
     "dictionary",
     "list"
   };
   CHECK(static_cast<size_t>(type) < arraysize(strings));
   return std::string(strings[type]);
 }
 
 ConfigurationPolicyHandler::ConfigurationPolicyHandler() {
 }
 
 ConfigurationPolicyHandler::~ConfigurationPolicyHandler() {
 }
 
 void ConfigurationPolicyHandler::PrepareForDisplaying(
     PolicyMap* policies) const {}
 
 
 // TypeCheckingPolicyHandler implementation ------------------------------------
 
 TypeCheckingPolicyHandler::TypeCheckingPolicyHandler(
     const char* policy_name,
-    Value::Type value_type)
+    base::Value::Type value_type)
     : policy_name_(policy_name),
       value_type_(value_type) {
 }
 
 TypeCheckingPolicyHandler::~TypeCheckingPolicyHandler() {
 }
 
 const char* TypeCheckingPolicyHandler::policy_name() const {
   return policy_name_;
 }
 
 bool TypeCheckingPolicyHandler::CheckPolicySettings(const PolicyMap& policies,
                                                     PolicyErrorMap* errors) {
-  const Value* value = NULL;
+  const base::Value* value = NULL;
   return CheckAndGetValue(policies, errors, &value);
 }
 
 bool TypeCheckingPolicyHandler::CheckAndGetValue(const PolicyMap& policies,
                                                  PolicyErrorMap* errors,
-                                                 const Value** value) {
+                                                 const base::Value** value) {
   *value = policies.GetValue(policy_name_);
   if (*value && !(*value)->IsType(value_type_)) {
     errors->AddError(policy_name_,
                      IDS_POLICY_TYPE_ERROR,
                      ValueTypeToString(value_type_));
     return false;
   }
   return true;
 }
 
@@ skipping 184 matching lines @@
         static_cast<double>(percentage) / 100.));
   }
 }
 
 
 // SimplePolicyHandler implementation ------------------------------------------
 
 SimplePolicyHandler::SimplePolicyHandler(
     const char* policy_name,
     const char* pref_path,
-    Value::Type value_type)
+    base::Value::Type value_type)
     : TypeCheckingPolicyHandler(policy_name, value_type),
       pref_path_(pref_path) {
 }
 
 SimplePolicyHandler::~SimplePolicyHandler() {
 }
 
 void SimplePolicyHandler::ApplyPolicySettings(const PolicyMap& policies,
                                               PrefValueMap* prefs) {
   if (!pref_path_)
     return;
-  const Value* value = policies.GetValue(policy_name());
+  const base::Value* value = policies.GetValue(policy_name());
   if (value)
     prefs->SetValue(pref_path_, value->DeepCopy());
 }
 
 }  // namespace policy