Remove FundamentalValue

components/arc/bluetooth/bluetooth_type_converters_unittest.cc

 // Copyright 2016 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/arc/bluetooth/bluetooth_type_converters.h"
 
 #include <algorithm>
 #include <memory>
 #include <string>
 #include <vector>
@@ skipping 45 matching lines @@
     size_t depth) {
   if (depth > 0u) {
     std::unique_ptr<bluez::BluetoothServiceAttributeValueBlueZ::Sequence>
         sequence(new bluez::BluetoothServiceAttributeValueBlueZ::Sequence());
     sequence->push_back(CreateDeepBlueZSequenceAttribute(depth - 1));
 
     return bluez::BluetoothServiceAttributeValueBlueZ(std::move(sequence));
   } else {
     return bluez::BluetoothServiceAttributeValueBlueZ(
         bluez::BluetoothServiceAttributeValueBlueZ::UINT, sizeof(uint16_t),
-        base::WrapUnique(new base::FundamentalValue(3)));
+        base::WrapUnique(new base::Value(3)));
   }
 }
 
 size_t GetDepthOfBlueZAttribute(
     const bluez::BluetoothServiceAttributeValueBlueZ& attribute) {
   size_t depth = 1;
   if (attribute.type() ==
       bluez::BluetoothServiceAttributeValueBlueZ::SEQUENCE) {
     for (const auto& value : attribute.sequence())
       depth = std::max(depth, GetDepthOfBlueZAttribute(value) + 1);
@@ skipping 245 matching lines @@
             nulltypeAttributeMojo->type);
   EXPECT_EQ(0u, nulltypeAttributeMojo->type_size);
   EXPECT_TRUE(nulltypeAttributeMojo->value.Get(0, &actualValue));
   EXPECT_EQ(base::Value::TYPE_NULL, actualValue->GetType());
 
   // Check integer types (INT, UINT).
   uint16_t valueUint16 = 10;
   int valueUint16AsInt;
   auto uintAttributeBlueZ = bluez::BluetoothServiceAttributeValueBlueZ(
       bluez::BluetoothServiceAttributeValueBlueZ::UINT, sizeof(valueUint16),
-      base::MakeUnique<base::FundamentalValue>(
-          base::FundamentalValue(static_cast<int>(valueUint16))));
+      base::MakeUnique<base::Value>(
+          base::Value(static_cast<int>(valueUint16))));
 
   auto uintAttributeMojo =
       ConvertTo<arc::mojom::BluetoothSdpAttributePtr>(uintAttributeBlueZ);
 
   EXPECT_EQ(bluez::BluetoothServiceAttributeValueBlueZ::UINT,
             uintAttributeMojo->type);
   EXPECT_EQ(sizeof(valueUint16), uintAttributeMojo->type_size);
   EXPECT_TRUE(uintAttributeMojo->value.GetInteger(0, &valueUint16AsInt));
   EXPECT_EQ(valueUint16, static_cast<uint16_t>(valueUint16AsInt));
 
   // Check bool type.
   bool valueBool = false;
   bool actualBool = true;
   auto boolAttributeBlueZ = bluez::BluetoothServiceAttributeValueBlueZ(
       bluez::BluetoothServiceAttributeValueBlueZ::BOOL, sizeof(bool),
-      base::MakeUnique<base::FundamentalValue>(
-          base::FundamentalValue(valueBool)));
+      base::MakeUnique<base::Value>(
+          base::Value(valueBool)));
 
   auto boolAttributeMojo =
       ConvertTo<arc::mojom::BluetoothSdpAttributePtr>(boolAttributeBlueZ);
 
   EXPECT_EQ(bluez::BluetoothServiceAttributeValueBlueZ::BOOL,
             boolAttributeMojo->type);
   EXPECT_EQ(static_cast<uint32_t>(sizeof(valueBool)),
             boolAttributeMojo->type_size);
   EXPECT_TRUE(boolAttributeMojo->value.GetBoolean(0, &actualBool));
   EXPECT_FALSE(valueBool);
@@ skipping 37 matching lines @@
   std::string l2capUUID("00000100-0000-1000-8000-00805f9b34fb");
   uint16_t l2capChannel = 3;
 
   std::unique_ptr<bluez::BluetoothServiceAttributeValueBlueZ::Sequence>
       sequence(new bluez::BluetoothServiceAttributeValueBlueZ::Sequence());
   sequence->push_back(bluez::BluetoothServiceAttributeValueBlueZ(
       bluez::BluetoothServiceAttributeValueBlueZ::UUID, sizeof(uint16_t),
       base::MakeUnique<base::StringValue>(base::StringValue(l2capUUID))));
   sequence->push_back(bluez::BluetoothServiceAttributeValueBlueZ(
       bluez::BluetoothServiceAttributeValueBlueZ::UINT, sizeof(uint16_t),
-      base::MakeUnique<base::FundamentalValue>(
-          base::FundamentalValue(l2capChannel))));
+      base::MakeUnique<base::Value>(
+          base::Value(l2capChannel))));
 
   auto sequenceBlueZ =
       bluez::BluetoothServiceAttributeValueBlueZ(std::move(sequence));
 
   ASSERT_EQ(2u, sequenceBlueZ.sequence().size());
 
   auto sequenceMojo =
       ConvertTo<arc::mojom::BluetoothSdpAttributePtr>(sequenceBlueZ);
 
   EXPECT_EQ(bluez::BluetoothServiceAttributeValueBlueZ::SEQUENCE,
@@ skipping 27 matching lines @@
   auto sequenceMojo =
       ConvertTo<arc::mojom::BluetoothSdpAttributePtr>(sequenceBlueZ);
 
   EXPECT_EQ(bluez::BluetoothServiceAttributeValueBlueZ::SEQUENCE,
             sequenceMojo->type);
   EXPECT_EQ((uint32_t)1, sequenceMojo->type_size);
   EXPECT_EQ(arc::kBluetoothSDPMaxDepth, GetDepthOfMojoAttribute(sequenceMojo));
 }
 
 }  // namespace mojo