Make base::Value::TYPE a scoped enum.

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 104 matching lines @@
       bluez::BluetoothServiceAttributeValueBlueZ::NULLTYPE;
   nulltypeAttributeMojo->type_size = 0;
   nulltypeAttributeMojo->value.Append(base::Value::CreateNullValue());
 
   auto nulltypeAttributeBlueZ =
       nulltypeAttributeMojo.To<bluez::BluetoothServiceAttributeValueBlueZ>();
 
   EXPECT_EQ(bluez::BluetoothServiceAttributeValueBlueZ::NULLTYPE,
             nulltypeAttributeBlueZ.type());
   EXPECT_EQ(0u, nulltypeAttributeBlueZ.size());
-  EXPECT_EQ(base::Value::TYPE_NULL, nulltypeAttributeBlueZ.value().GetType());
+  EXPECT_EQ(base::Value::Type::NONE, nulltypeAttributeBlueZ.value().GetType());
 
   // Construct Mojo attribute with TYPE_BOOLEAN value.
   bool valueBool = true;
   auto boolAttributeMojo = arc::mojom::BluetoothSdpAttribute::New();
   boolAttributeMojo->type = bluez::BluetoothServiceAttributeValueBlueZ::BOOL;
   boolAttributeMojo->type_size = static_cast<uint32_t>(sizeof(valueBool));
   boolAttributeMojo->value.AppendBoolean(valueBool);
   auto boolAttributeBlueZ =
       boolAttributeMojo.To<bluez::BluetoothServiceAttributeValueBlueZ>();
 
   EXPECT_EQ(bluez::BluetoothServiceAttributeValueBlueZ::BOOL,
             boolAttributeBlueZ.type());
   EXPECT_EQ(sizeof(valueBool), boolAttributeBlueZ.size());
-  EXPECT_EQ(base::Value::TYPE_BOOLEAN, boolAttributeBlueZ.value().GetType());
+  EXPECT_EQ(base::Value::Type::BOOLEAN, boolAttributeBlueZ.value().GetType());
   EXPECT_TRUE(boolAttributeBlueZ.value().GetAsBoolean(&valueBool));
   EXPECT_TRUE(valueBool);
 
   // Construct Mojo attribute with TYPE_UINT value.
   uint16_t valueUint16 = 10;
   int valueUint16AsInt = 0;
   auto uintAttributeMojo = arc::mojom::BluetoothSdpAttribute::New();
   uintAttributeMojo->type = bluez::BluetoothServiceAttributeValueBlueZ::UINT;
   uintAttributeMojo->type_size = static_cast<uint32_t>(sizeof(valueUint16));
   uintAttributeMojo->value.AppendInteger(static_cast<int>(valueUint16));
 
   auto uintAttributeBlueZ =
       uintAttributeMojo.To<bluez::BluetoothServiceAttributeValueBlueZ>();
 
   EXPECT_EQ(bluez::BluetoothServiceAttributeValueBlueZ::UINT,
             uintAttributeBlueZ.type());
   EXPECT_EQ(sizeof(valueUint16), uintAttributeBlueZ.size());
-  EXPECT_EQ(base::Value::TYPE_INTEGER, uintAttributeBlueZ.value().GetType());
+  EXPECT_EQ(base::Value::Type::INTEGER, uintAttributeBlueZ.value().GetType());
   EXPECT_TRUE(uintAttributeBlueZ.value().GetAsInteger(&valueUint16AsInt));
   EXPECT_EQ(valueUint16, static_cast<uint16_t>(valueUint16AsInt));
 
   // Construct Mojo attribute with TYPE_INT value.
   int16_t valueInt16 = 20;
   int valueInt16AsInt = 0;
   auto intAttributeMojo = arc::mojom::BluetoothSdpAttribute::New();
   intAttributeMojo->type = bluez::BluetoothServiceAttributeValueBlueZ::INT;
   intAttributeMojo->type_size = static_cast<uint32_t>(sizeof(valueInt16));
   intAttributeMojo->value.AppendInteger(static_cast<int>(valueInt16));
 
   auto intAttributeBlueZ =
       intAttributeMojo.To<bluez::BluetoothServiceAttributeValueBlueZ>();
 
   EXPECT_EQ(bluez::BluetoothServiceAttributeValueBlueZ::INT,
             intAttributeBlueZ.type());
   EXPECT_EQ(sizeof(valueInt16), intAttributeBlueZ.size());
-  EXPECT_EQ(base::Value::TYPE_INTEGER, intAttributeBlueZ.value().GetType());
+  EXPECT_EQ(base::Value::Type::INTEGER, intAttributeBlueZ.value().GetType());
   EXPECT_TRUE(intAttributeBlueZ.value().GetAsInteger(&valueInt16AsInt));
   EXPECT_EQ(valueInt16, static_cast<int16_t>(valueInt16AsInt));
 
   // Construct Mojo attribute with TYPE_UUID.
   std::string expectedUUID("00000000-0000-1000-8000-00805f9b34fb");
   std::string actualUUID;
   auto uuidAttributeMojo = arc::mojom::BluetoothSdpAttribute::New();
   uuidAttributeMojo->type = bluez::BluetoothServiceAttributeValueBlueZ::UUID;
   // UUIDs are all stored in string form, but it can be converted to one of
   // UUID16, UUID32 and UUID128.
   uuidAttributeMojo->type_size = static_cast<uint32_t>(sizeof(uint16_t));
   uuidAttributeMojo->value.AppendString(expectedUUID);
 
   auto uuidAttributeBlueZ =
       uuidAttributeMojo.To<bluez::BluetoothServiceAttributeValueBlueZ>();
 
   EXPECT_EQ(bluez::BluetoothServiceAttributeValueBlueZ::UUID,
             uuidAttributeBlueZ.type());
   EXPECT_EQ(sizeof(uint16_t), uuidAttributeBlueZ.size());
-  EXPECT_EQ(base::Value::TYPE_STRING, uuidAttributeBlueZ.value().GetType());
+  EXPECT_EQ(base::Value::Type::STRING, uuidAttributeBlueZ.value().GetType());
   EXPECT_TRUE(uuidAttributeBlueZ.value().GetAsString(&actualUUID));
   EXPECT_EQ(expectedUUID, actualUUID);
 
   // Construct Mojo attribute with TYPE_STRING. TYPE_URL is the same case as
   // TYPE_STRING.
   std::string expectedString("Some SDP service");
   std::string actualString;
   auto stringAttributeMojo = arc::mojom::BluetoothSdpAttribute::New();
   stringAttributeMojo->type =
       bluez::BluetoothServiceAttributeValueBlueZ::STRING;
   stringAttributeMojo->type_size =
       static_cast<uint32_t>(expectedString.length());
   stringAttributeMojo->value.AppendString(expectedString);
 
   auto stringAttributeBlueZ =
       stringAttributeMojo.To<bluez::BluetoothServiceAttributeValueBlueZ>();
 
   EXPECT_EQ(bluez::BluetoothServiceAttributeValueBlueZ::STRING,
             stringAttributeBlueZ.type());
   EXPECT_EQ(expectedString.length(), stringAttributeBlueZ.size());
-  EXPECT_EQ(base::Value::TYPE_STRING, stringAttributeBlueZ.value().GetType());
+  EXPECT_EQ(base::Value::Type::STRING, stringAttributeBlueZ.value().GetType());
   EXPECT_TRUE(stringAttributeBlueZ.value().GetAsString(&actualString));
   EXPECT_EQ(expectedString, actualString);
 }
 
 TEST(BluetoothTypeConvertorTest, ConvertMojoSequenceAttributeToBlueZAttribute) {
   // Create an UUID value.
   std::string l2capUUID("00000100-0000-1000-8000-00805f9b34fb");
   auto valueUUID = arc::mojom::BluetoothSdpAttribute::New();
   valueUUID->type = bluez::BluetoothServiceAttributeValueBlueZ::UUID;
   valueUUID->type_size = static_cast<uint32_t>(sizeof(uint16_t));
@@ skipping 44 matching lines @@
   valueNoData->type = bluez::BluetoothServiceAttributeValueBlueZ::UINT;
   valueNoData->type_size = static_cast<uint32_t>(sizeof(uint32_t));
   valueNoData->value.Clear();
 
   auto valueNoDataBlueZ =
       valueNoData.To<bluez::BluetoothServiceAttributeValueBlueZ>();
 
   EXPECT_EQ(bluez::BluetoothServiceAttributeValueBlueZ::NULLTYPE,
             valueNoDataBlueZ.type());
   EXPECT_EQ(0u, valueNoDataBlueZ.size());
-  EXPECT_EQ(base::Value::TYPE_NULL, valueNoDataBlueZ.value().GetType());
+  EXPECT_EQ(base::Value::Type::NONE, valueNoDataBlueZ.value().GetType());
 }
 
 TEST(BluetoothTypeConvertorTest,
      ConvertInvalidMojoSequenceAttributeToBlueZAttribute) {
   // Create a Mojo attribute with an empty sequence.
   auto sequenceNoData = arc::mojom::BluetoothSdpAttribute::New();
   sequenceNoData->type = bluez::BluetoothServiceAttributeValueBlueZ::SEQUENCE;
   sequenceNoData->type_size = 0;
   sequenceNoData->value.Append(base::Value::CreateNullValue());
 
   auto sequenceNoDataBlueZ =
       sequenceNoData.To<bluez::BluetoothServiceAttributeValueBlueZ>();
 
   EXPECT_EQ(bluez::BluetoothServiceAttributeValueBlueZ::NULLTYPE,
             sequenceNoDataBlueZ.type());
   EXPECT_EQ(0u, sequenceNoDataBlueZ.size());
-  EXPECT_EQ(base::Value::TYPE_NULL, sequenceNoDataBlueZ.value().GetType());
+  EXPECT_EQ(base::Value::Type::NONE, sequenceNoDataBlueZ.value().GetType());
 
   // Create a Mojo attribute with the depth = arc::kBluetoothSDPMaxDepth + 3.
   auto sequenceTooDeepMojo =
       CreateDeepMojoSequenceAttribute(arc::kBluetoothSDPMaxDepth + 3);
   auto sequenceTooDeepBlueZ =
       sequenceTooDeepMojo.To<bluez::BluetoothServiceAttributeValueBlueZ>();
 
   EXPECT_EQ(bluez::BluetoothServiceAttributeValueBlueZ::SEQUENCE,
             sequenceTooDeepBlueZ.type());
   EXPECT_EQ(1u, sequenceTooDeepBlueZ.size());
   EXPECT_EQ(arc::kBluetoothSDPMaxDepth,
             GetDepthOfBlueZAttribute(sequenceTooDeepBlueZ));
 }
 
 TEST(BluetoothTypeConvertorTest, ConvertBlueZValueAttributeToMojoAttribute) {
   // Check NULL type.
   auto nulltypeAttributeBlueZ = bluez::BluetoothServiceAttributeValueBlueZ();
   base::Value* actualValue;
 
   auto nulltypeAttributeMojo =
       ConvertTo<arc::mojom::BluetoothSdpAttributePtr>(nulltypeAttributeBlueZ);
 
   EXPECT_EQ(bluez::BluetoothServiceAttributeValueBlueZ::NULLTYPE,
             nulltypeAttributeMojo->type);
   EXPECT_EQ(0u, nulltypeAttributeMojo->type_size);
   EXPECT_TRUE(nulltypeAttributeMojo->value.Get(0, &actualValue));
-  EXPECT_EQ(base::Value::TYPE_NULL, actualValue->GetType());
+  EXPECT_EQ(base::Value::Type::NONE, 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))));
 
   auto uintAttributeMojo =
@@ skipping 111 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