Remove FundamentalValue

chromecast/base/device_capabilities_impl_unittest.cc

 // Copyright 2015 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 "chromecast/base/device_capabilities_impl.h"
 
 #include <string>
 #include <utility>
 
 #include "base/macros.h"
@@ skipping 135 matching lines @@
   DISALLOW_COPY_AND_ASSIGN(MockCapabilitiesObserver);
 };
 
 // Test fixtures needs an example default capability to test DeviceCapabilities
 // methods. Gets a sample key and initial value.
 void GetSampleDefaultCapability(std::string* key,
                                 std::unique_ptr<base::Value>* init_value) {
   DCHECK(key);
   DCHECK(init_value);
   *key = DeviceCapabilities::kKeyBluetoothSupported;
-  *init_value = base::MakeUnique<base::FundamentalValue>(true);
+  *init_value = base::MakeUnique<base::Value>(true);
 }
 
 // For test fixtures that test dynamic capabilities, gets a sample key
 // and initial value.
 void GetSampleDynamicCapability(std::string* key,
                                 std::unique_ptr<base::Value>* init_value) {
   DCHECK(key);
   DCHECK(init_value);
   *key = "dummy_dynamic_key";
-  *init_value = base::MakeUnique<base::FundamentalValue>(99);
+  *init_value = base::MakeUnique<base::Value>(99);
 }
 
 // Gets a value for sample default capability different from |init_value|
 // returned in GetSampleDefaultCapability(). Must be of same type as
 // |init_value| of course.
 std::unique_ptr<base::Value> GetSampleDefaultCapabilityNewValue() {
-  return base::MakeUnique<base::FundamentalValue>(false);
+  return base::MakeUnique<base::Value>(false);
 }
 
 // Gets a value for sample dynamic capability different from |init_value|
 // returned in GetSampleDynamicCapability(). Must be of same type as
 // |init_value| of course.
 std::unique_ptr<base::Value> GetSampleDynamicCapabilityNewValue() {
-  return base::MakeUnique<base::FundamentalValue>(100);
+  return base::MakeUnique<base::Value>(100);
 }
 
 // Tests that |json| string matches contents of a DictionaryValue with one entry
 // specified by |key| and |value|.
 bool JsonStringEquals(const std::string& json,
                       const std::string& key,
                       const base::Value& value) {
   base::DictionaryValue dict_value;
   dict_value.Set(key, value.CreateDeepCopy());
   std::unique_ptr<const std::string> dict_json(SerializeToJson(dict_value));
@@ skipping 140 matching lines @@
   capabilities()->SetCapability(key, new_value->CreateDeepCopy());
   base::RunLoop().RunUntilIdle();
   EXPECT_TRUE(base::Value::Equals(capabilities()->GetCapability(key).get(),
                                   new_value.get()));
 }
 
 // Tests BluetoothSupported() and updating this value through SetCapability().
 TEST_F(DeviceCapabilitiesImplTest, BluetoothSupportedAndSetCapability) {
   FakeCapabilityManagerSimple manager(
       capabilities(), DeviceCapabilities::kKeyBluetoothSupported,
-      base::WrapUnique(new base::FundamentalValue(true)), true, false);
+      base::WrapUnique(new base::Value(true)), true, false);
 
   EXPECT_TRUE(capabilities()->BluetoothSupported());
   capabilities()->SetCapability(
       DeviceCapabilities::kKeyBluetoothSupported,
-      base::WrapUnique(new base::FundamentalValue(false)));
+      base::WrapUnique(new base::Value(false)));
   base::RunLoop().RunUntilIdle();
   EXPECT_FALSE(capabilities()->BluetoothSupported());
 }
 
 // Tests DisplaySupported() and updating this value through SetCapability().
 TEST_F(DeviceCapabilitiesImplTest, DisplaySupportedAndSetCapability) {
   FakeCapabilityManagerSimple manager(
       capabilities(), DeviceCapabilities::kKeyDisplaySupported,
-      base::WrapUnique(new base::FundamentalValue(true)), true, false);
+      base::WrapUnique(new base::Value(true)), true, false);
 
   EXPECT_TRUE(capabilities()->DisplaySupported());
   capabilities()->SetCapability(
       DeviceCapabilities::kKeyDisplaySupported,
-      base::WrapUnique(new base::FundamentalValue(false)));
+      base::WrapUnique(new base::Value(false)));
   base::RunLoop().RunUntilIdle();
   EXPECT_FALSE(capabilities()->DisplaySupported());
 }
 
 // Tests HiResAudioSupported() and updating this value through SetCapability()
 TEST_F(DeviceCapabilitiesImplTest, HiResAudioSupportedAndSetCapability) {
   FakeCapabilityManagerSimple manager(
       capabilities(), DeviceCapabilities::kKeyHiResAudioSupported,
-      base::WrapUnique(new base::FundamentalValue(true)), true, false);
+      base::WrapUnique(new base::Value(true)), true, false);
 
   EXPECT_TRUE(capabilities()->HiResAudioSupported());
   capabilities()->SetCapability(
       DeviceCapabilities::kKeyHiResAudioSupported,
-      base::WrapUnique(new base::FundamentalValue(false)));
+      base::WrapUnique(new base::Value(false)));
   base::RunLoop().RunUntilIdle();
   EXPECT_FALSE(capabilities()->HiResAudioSupported());
 }
 
 // Tests AssistantSupported() and updating this value through SetCapability()
 TEST_F(DeviceCapabilitiesImplTest, AssistantSupportedAndSetCapability) {
   FakeCapabilityManagerSimple manager(
       capabilities(), DeviceCapabilities::kKeyAssistantSupported,
-      base::WrapUnique(new base::FundamentalValue(true)), true, false);
+      base::WrapUnique(new base::Value(true)), true, false);
 
   EXPECT_TRUE(capabilities()->AssistantSupported());
   capabilities()->SetCapability(
       DeviceCapabilities::kKeyAssistantSupported,
-      base::WrapUnique(new base::FundamentalValue(false)));
+      base::WrapUnique(new base::Value(false)));
   base::RunLoop().RunUntilIdle();
   EXPECT_FALSE(capabilities()->AssistantSupported());
 }
 
 // Tests SetCapability() for a default capability when the capability's manager
 // rejects the proposed change.
 TEST_F(DeviceCapabilitiesImplTest, SetCapabilityInvalid) {
   std::string key;
   std::unique_ptr<base::Value> init_value;
   GetSampleDefaultCapability(&key, &init_value);
@@ skipping 22 matching lines @@
   capabilities()->SetCapability(key, new_value->CreateDeepCopy());
   base::RunLoop().RunUntilIdle();
   EXPECT_TRUE(JsonStringEquals(capabilities()->GetAllData()->json_string(), key,
                                *new_value));
 }
 
 // Tests that GetPublicData() does not include private capabilities
 TEST_F(DeviceCapabilitiesImplTest, SetPublicPrivateCapabilities) {
   std::string key_private = "private";
   std::string key_public = "public";
-  std::unique_ptr<base::Value> init_value(new base::FundamentalValue(true));
+  std::unique_ptr<base::Value> init_value(new base::Value(true));
 
   // Dictionary of only public values.
   base::DictionaryValue public_dict;
   public_dict.Set(key_public, init_value->CreateDeepCopy());
   // Dictionary of public and private values.
   base::DictionaryValue full_dict;
   full_dict.Set(key_public, init_value->CreateDeepCopy());
   full_dict.Set(key_private, init_value->CreateDeepCopy());
 
   FakeCapabilityManagerSimple public_manager(
       capabilities(), key_public, init_value->CreateDeepCopy(), true, false);
   FakeCapabilityManagerSimple private_manager(
       capabilities(), key_private, init_value->CreateDeepCopy(), true, true);
 
   EXPECT_TRUE(capabilities()->GetAllData()->dictionary().Equals(&full_dict));
   EXPECT_TRUE(
       capabilities()->GetPublicData()->dictionary().Equals(&public_dict));
 }
 
 // Tests that SetCapability() defaults to making a capability public
 TEST_F(DeviceCapabilitiesImplTest, NoValidatorDefaultsToPublicCapability) {
   std::string key_private = "private";
   std::string key_public = "public";
-  std::unique_ptr<base::Value> init_value(new base::FundamentalValue(true));
+  std::unique_ptr<base::Value> init_value(new base::Value(true));
 
   // Dictionary of only public values.
   base::DictionaryValue public_dict;
   public_dict.Set(key_public, init_value->CreateDeepCopy());
   // Dictionary of public and private values.
   base::DictionaryValue full_dict;
   full_dict.Set(key_public, init_value->CreateDeepCopy());
   full_dict.Set(key_private, init_value->CreateDeepCopy());
 
   // We will not create a validator for the public capability; instead we will
@@ skipping 86 matching lines @@
 TEST_F(DeviceCapabilitiesImplTest, SetCapabilityDictionary) {
   std::string key("dummy_dictionary_key");
   std::unique_ptr<base::Value> init_value =
       DeserializeFromJson(kSampleDictionaryCapability);
   ASSERT_TRUE(init_value);
   FakeCapabilityManagerSimple manager(capabilities(), key,
                                       std::move(init_value), true, false);
 
   capabilities()->SetCapability(
       "dummy_dictionary_key.dummy_field_bool",
-      base::WrapUnique(new base::FundamentalValue(false)));
+      base::WrapUnique(new base::Value(false)));
   base::RunLoop().RunUntilIdle();
   bool value_bool = true;
   std::unique_ptr<base::Value> value =
       capabilities()->GetCapability("dummy_dictionary_key.dummy_field_bool");
   ASSERT_TRUE(value);
   EXPECT_TRUE(value->GetAsBoolean(&value_bool));
   EXPECT_FALSE(value_bool);
 
   capabilities()->SetCapability(
       "dummy_dictionary_key.dummy_field_int",
-      base::WrapUnique(new base::FundamentalValue(100)));
+      base::WrapUnique(new base::Value(100)));
   base::RunLoop().RunUntilIdle();
   int value_int = 0;
   value = capabilities()->GetCapability("dummy_dictionary_key.dummy_field_int");
   ASSERT_TRUE(value);
   EXPECT_TRUE(value->GetAsInteger(&value_int));
   EXPECT_EQ(value_int, 100);
 }
 
 // Tests that SetCapability() works with expanded paths when there is a
 // capability of type DictionaryValue and invalid changes are proposed.
 TEST_F(DeviceCapabilitiesImplTest, SetCapabilityDictionaryInvalid) {
   std::string key("dummy_dictionary_key");
   std::unique_ptr<base::Value> init_value =
       DeserializeFromJson(kSampleDictionaryCapability);
   ASSERT_TRUE(init_value);
   FakeCapabilityManagerSimple manager(capabilities(), key,
                                       std::move(init_value), false, false);
 
   capabilities()->SetCapability(
       "dummy_dictionary_key.dummy_field_bool",
-      base::WrapUnique(new base::FundamentalValue(false)));
+      base::WrapUnique(new base::Value(false)));
   base::RunLoop().RunUntilIdle();
   bool value_bool = false;
   std::unique_ptr<base::Value> value =
       capabilities()->GetCapability("dummy_dictionary_key.dummy_field_bool");
   ASSERT_TRUE(value);
   EXPECT_TRUE(value->GetAsBoolean(&value_bool));
   EXPECT_TRUE(value_bool);
 
   capabilities()->SetCapability(
       "dummy_dictionary_key.dummy_field_int",
-      base::WrapUnique(new base::FundamentalValue(100)));
+      base::WrapUnique(new base::Value(100)));
   base::RunLoop().RunUntilIdle();
   int value_int = 0;
   value = capabilities()->GetCapability("dummy_dictionary_key.dummy_field_int");
   ASSERT_TRUE(value);
   EXPECT_TRUE(value->GetAsInteger(&value_int));
   EXPECT_EQ(value_int, 99);
 }
 
 // Test  MergeDictionary.
 TEST_F(DeviceCapabilitiesImplTest, MergeDictionary) {
@@ skipping 42 matching lines @@
 }
 
 // Tests that it is safe to call DeviceCapabilities methods in
 // an Observer's OnCapabilitiesChanged() implementation safely with correct
 // behavior and without deadlocking.
 TEST_F(DeviceCapabilitiesImplTest, OnCapabilitiesChangedSafe) {
   FakeCapabilitiesObserver observer(capabilities());
 
   // Trigger FakeCapabilitiesObserver::OnCapabilitiesChanged()
   capabilities()->SetCapability(
-      "dummy_trigger_key", base::WrapUnique(new base::FundamentalValue(true)));
+      "dummy_trigger_key", base::WrapUnique(new base::Value(true)));
   base::RunLoop().RunUntilIdle();
 
   // Check that FakeCapabilitiesObserver::OnCapabilitiesChanged() ran and that
   // behavior was successful
   AssertBasicOperationsSuccessful(capabilities());
 }
 
 // Tests that it is safe to call DeviceCapabilities methods in a Validator's
 // Validate() implementation safely with correct behavior and without
 // deadlocking.
 TEST_F(DeviceCapabilitiesImplTest, ValidateSafe) {
   FakeCapabilityManagerComplex manager(capabilities(), "dummy_validate_key");
 
   // Trigger FakeCapabilityManagerComplex::Validate()
   capabilities()->SetCapability(
-      "dummy_validate_key", base::WrapUnique(new base::FundamentalValue(true)));
+      "dummy_validate_key", base::WrapUnique(new base::Value(true)));
   base::RunLoop().RunUntilIdle();
 
   // Check that FakeCapabilityManagerComplex::Validate() ran and that behavior
   // was successful
   AssertBasicOperationsSuccessful(capabilities());
 }
 
 }  // namespace chromecast