Make base use the proper Value namespace

base/prefs/pref_value_store_unittest.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 <string>
 
 #include "base/bind.h"
 #include "base/memory/ref_counted.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/prefs/pref_notifier.h"
@@ skipping 203 matching lines @@
 
   scoped_refptr<TestingPrefStore> managed_pref_store_;
   scoped_refptr<TestingPrefStore> extension_pref_store_;
   scoped_refptr<TestingPrefStore> command_line_pref_store_;
   scoped_refptr<TestingPrefStore> user_pref_store_;
   scoped_refptr<TestingPrefStore> recommended_pref_store_;
   scoped_refptr<TestingPrefStore> default_pref_store_;
 };
 
 TEST_F(PrefValueStoreTest, GetValue) {
-  const Value* value;
+  const base::Value* value;
 
   // The following tests read a value from the PrefService. The preferences are
   // set in a way such that all lower-priority stores have a value and we can
   // test whether overrides work correctly.
 
   // Test getting a managed value.
   value = NULL;
   ASSERT_TRUE(pref_value_store_->GetValue(prefs::kManagedPref,
-                                          Value::TYPE_STRING, &value));
+                                          base::Value::TYPE_STRING, &value));
   std::string actual_str_value;
   EXPECT_TRUE(value->GetAsString(&actual_str_value));
   EXPECT_EQ(managed_pref::kManagedValue, actual_str_value);
 
   // Test getting an extension value.
   value = NULL;
   ASSERT_TRUE(pref_value_store_->GetValue(prefs::kExtensionPref,
-                                          Value::TYPE_STRING, &value));
+                                          base::Value::TYPE_STRING, &value));
   EXPECT_TRUE(value->GetAsString(&actual_str_value));
   EXPECT_EQ(extension_pref::kExtensionValue, actual_str_value);
 
   // Test getting a command-line value.
   value = NULL;
   ASSERT_TRUE(pref_value_store_->GetValue(prefs::kCommandLinePref,
-                                          Value::TYPE_STRING, &value));
+                                          base::Value::TYPE_STRING, &value));
   EXPECT_TRUE(value->GetAsString(&actual_str_value));
   EXPECT_EQ(command_line_pref::kCommandLineValue, actual_str_value);
 
   // Test getting a user-set value.
   value = NULL;
   ASSERT_TRUE(pref_value_store_->GetValue(prefs::kUserPref,
-                                          Value::TYPE_STRING, &value));
+                                          base::Value::TYPE_STRING, &value));
   EXPECT_TRUE(value->GetAsString(&actual_str_value));
   EXPECT_EQ(user_pref::kUserValue, actual_str_value);
 
   // Test getting a user set value overwriting a recommended value.
   value = NULL;
   ASSERT_TRUE(pref_value_store_->GetValue(prefs::kRecommendedPref,
-                                          Value::TYPE_STRING, &value));
+                                          base::Value::TYPE_STRING, &value));
   EXPECT_TRUE(value->GetAsString(&actual_str_value));
   EXPECT_EQ(recommended_pref::kRecommendedValue,
             actual_str_value);
 
   // Test getting a default value.
   value = NULL;
   ASSERT_TRUE(pref_value_store_->GetValue(prefs::kDefaultPref,
-                                          Value::TYPE_STRING, &value));
+                                          base::Value::TYPE_STRING, &value));
   EXPECT_TRUE(value->GetAsString(&actual_str_value));
   EXPECT_EQ(default_pref::kDefaultValue, actual_str_value);
 
   // Test getting a preference value that the |PrefValueStore|
   // does not contain.
   base::FundamentalValue tmp_dummy_value(true);
   value = &tmp_dummy_value;
   ASSERT_FALSE(pref_value_store_->GetValue(prefs::kMissingPref,
-                                           Value::TYPE_STRING, &value));
+                                           base::Value::TYPE_STRING, &value));
   ASSERT_FALSE(value);
 }
 
 TEST_F(PrefValueStoreTest, GetRecommendedValue) {
-  const Value* value;
+  const base::Value* value;
 
   // The following tests read a value from the PrefService. The preferences are
   // set in a way such that all lower-priority stores have a value and we can
   // test whether overrides do not clutter the recommended value.
 
   // Test getting recommended value when a managed value is present.
   value = NULL;
   ASSERT_TRUE(pref_value_store_->GetRecommendedValue(
       prefs::kManagedPref,
-      Value::TYPE_STRING, &value));
+      base::Value::TYPE_STRING, &value));
   std::string actual_str_value;
   EXPECT_TRUE(value->GetAsString(&actual_str_value));
   EXPECT_EQ(recommended_pref::kManagedValue, actual_str_value);
 
   // Test getting recommended value when an extension value is present.
   value = NULL;
   ASSERT_TRUE(pref_value_store_->GetRecommendedValue(
       prefs::kExtensionPref,
-      Value::TYPE_STRING, &value));
+      base::Value::TYPE_STRING, &value));
   EXPECT_TRUE(value->GetAsString(&actual_str_value));
   EXPECT_EQ(recommended_pref::kExtensionValue, actual_str_value);
 
   // Test getting recommended value when a command-line value is present.
   value = NULL;
   ASSERT_TRUE(pref_value_store_->GetRecommendedValue(
       prefs::kCommandLinePref,
-      Value::TYPE_STRING, &value));
+      base::Value::TYPE_STRING, &value));
   EXPECT_TRUE(value->GetAsString(&actual_str_value));
   EXPECT_EQ(recommended_pref::kCommandLineValue, actual_str_value);
 
   // Test getting recommended value when a user-set value is present.
   value = NULL;
   ASSERT_TRUE(pref_value_store_->GetRecommendedValue(
       prefs::kUserPref,
-      Value::TYPE_STRING, &value));
+      base::Value::TYPE_STRING, &value));
   EXPECT_TRUE(value->GetAsString(&actual_str_value));
   EXPECT_EQ(recommended_pref::kUserValue, actual_str_value);
 
   // Test getting recommended value when no higher-priority value is present.
   value = NULL;
   ASSERT_TRUE(pref_value_store_->GetRecommendedValue(
       prefs::kRecommendedPref,
-      Value::TYPE_STRING, &value));
+      base::Value::TYPE_STRING, &value));
   EXPECT_TRUE(value->GetAsString(&actual_str_value));
   EXPECT_EQ(recommended_pref::kRecommendedValue,
             actual_str_value);
 
   // Test getting recommended value when no recommended value is present.
   base::FundamentalValue tmp_dummy_value(true);
   value = &tmp_dummy_value;
   ASSERT_FALSE(pref_value_store_->GetRecommendedValue(
       prefs::kDefaultPref,
-      Value::TYPE_STRING, &value));
+      base::Value::TYPE_STRING, &value));
   ASSERT_FALSE(value);
 
   // Test getting a preference value that the |PrefValueStore|
   // does not contain.
   value = &tmp_dummy_value;
   ASSERT_FALSE(pref_value_store_->GetRecommendedValue(
       prefs::kMissingPref,
-      Value::TYPE_STRING, &value));
+      base::Value::TYPE_STRING, &value));
   ASSERT_FALSE(value);
 }
 
 TEST_F(PrefValueStoreTest, PrefChanges) {
   // Check pref controlled by highest-priority store.
   ExpectValueChangeNotifications(prefs::kManagedPref);
   managed_pref_store_->NotifyPrefValueChanged(prefs::kManagedPref);
   CheckAndClearValueChangeNotifications();
 
   ExpectValueChangeNotifications(prefs::kManagedPref);
@@ skipping 227 matching lines @@
       prefs::kCommandLinePref));
   EXPECT_TRUE(pref_value_store_->PrefValueExtensionModifiable(
       prefs::kUserPref));
   EXPECT_TRUE(pref_value_store_->PrefValueExtensionModifiable(
       prefs::kRecommendedPref));
   EXPECT_TRUE(pref_value_store_->PrefValueExtensionModifiable(
       prefs::kDefaultPref));
   EXPECT_TRUE(pref_value_store_->PrefValueExtensionModifiable(
       prefs::kMissingPref));
 }