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

dbus/values_util.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 "dbus/values_util.h"
 
 #include <utility>
 
 #include "base/json/json_writer.h"
 #include "base/logging.h"
@@ skipping 49 matching lines @@
     if (!value)
       return false;
     dictionary_value->SetWithoutPathExpansion(key_string, std::move(value));
   }
   return true;
 }
 
 // Gets the D-Bus type signature for the value.
 std::string GetTypeSignature(const base::Value& value) {
   switch (value.GetType()) {
-    case base::Value::TYPE_BOOLEAN:
+    case base::Value::Type::BOOLEAN:
       return "b";
-    case base::Value::TYPE_INTEGER:
+    case base::Value::Type::INTEGER:
       return "i";
-    case base::Value::TYPE_DOUBLE:
+    case base::Value::Type::DOUBLE:
       return "d";
-    case base::Value::TYPE_STRING:
+    case base::Value::Type::STRING:
       return "s";
-    case base::Value::TYPE_BINARY:
+    case base::Value::Type::BINARY:
       return "ay";
-    case base::Value::TYPE_DICTIONARY:
+    case base::Value::Type::DICTIONARY:
       return "a{sv}";
-    case base::Value::TYPE_LIST:
+    case base::Value::Type::LIST:
       return "av";
     default:
       DLOG(ERROR) << "Unexpected type " << value.GetType();
       return std::string();
   }
 }
 
 }  // namespace
 
 std::unique_ptr<base::Value> PopDataAsValue(MessageReader* reader) {
@@ skipping 119 matching lines @@
       if (reader->PopVariant(&sub_reader))
         result = PopDataAsValue(&sub_reader);
       break;
     }
   }
   return result;
 }
 
 void AppendBasicTypeValueData(MessageWriter* writer, const base::Value& value) {
   switch (value.GetType()) {
-    case base::Value::TYPE_BOOLEAN: {
+    case base::Value::Type::BOOLEAN: {
       bool bool_value = false;
       bool success = value.GetAsBoolean(&bool_value);
       DCHECK(success);
       writer->AppendBool(bool_value);
       break;
     }
-    case base::Value::TYPE_INTEGER: {
+    case base::Value::Type::INTEGER: {
       int int_value = 0;
       bool success = value.GetAsInteger(&int_value);
       DCHECK(success);
       writer->AppendInt32(int_value);
       break;
     }
-    case base::Value::TYPE_DOUBLE: {
+    case base::Value::Type::DOUBLE: {
       double double_value = 0;
       bool success = value.GetAsDouble(&double_value);
       DCHECK(success);
       writer->AppendDouble(double_value);
       break;
     }
-    case base::Value::TYPE_STRING: {
+    case base::Value::Type::STRING: {
       std::string string_value;
       bool success = value.GetAsString(&string_value);
       DCHECK(success);
       writer->AppendString(string_value);
       break;
     }
     default:
       DLOG(ERROR) << "Unexpected type " << value.GetType();
       break;
   }
 }
 
 void AppendBasicTypeValueDataAsVariant(MessageWriter* writer,
                                        const base::Value& value) {
   MessageWriter sub_writer(NULL);
   writer->OpenVariant(GetTypeSignature(value), &sub_writer);
   AppendBasicTypeValueData(&sub_writer, value);
   writer->CloseContainer(&sub_writer);
 }
 
 void AppendValueData(MessageWriter* writer, const base::Value& value) {
   switch (value.GetType()) {
-    case base::Value::TYPE_DICTIONARY: {
+    case base::Value::Type::DICTIONARY: {
       const base::DictionaryValue* dictionary = NULL;
       value.GetAsDictionary(&dictionary);
       dbus::MessageWriter array_writer(NULL);
       writer->OpenArray("{sv}", &array_writer);
       for (base::DictionaryValue::Iterator iter(*dictionary);
            !iter.IsAtEnd(); iter.Advance()) {
         dbus::MessageWriter dict_entry_writer(NULL);
         array_writer.OpenDictEntry(&dict_entry_writer);
         dict_entry_writer.AppendString(iter.key());
         AppendValueDataAsVariant(&dict_entry_writer, iter.value());
         array_writer.CloseContainer(&dict_entry_writer);
       }
       writer->CloseContainer(&array_writer);
       break;
     }
-    case base::Value::TYPE_LIST: {
+    case base::Value::Type::LIST: {
       const base::ListValue* list = NULL;
       value.GetAsList(&list);
       dbus::MessageWriter array_writer(NULL);
       writer->OpenArray("v", &array_writer);
       for (const auto& value : *list) {
         AppendValueDataAsVariant(&array_writer, *value);
       }
       writer->CloseContainer(&array_writer);
       break;
     }
-    case base::Value::TYPE_BOOLEAN:
-    case base::Value::TYPE_INTEGER:
-    case base::Value::TYPE_DOUBLE:
-    case base::Value::TYPE_STRING:
+    case base::Value::Type::BOOLEAN:
+    case base::Value::Type::INTEGER:
+    case base::Value::Type::DOUBLE:
+    case base::Value::Type::STRING:
       AppendBasicTypeValueData(writer, value);
       break;
     default:
       DLOG(ERROR) << "Unexpected type: " << value.GetType();
   }
 }
 
 void AppendValueDataAsVariant(MessageWriter* writer, const base::Value& value) {
   MessageWriter variant_writer(NULL);
   writer->OpenVariant(GetTypeSignature(value), &variant_writer);
   AppendValueData(&variant_writer, value);
   writer->CloseContainer(&variant_writer);
 }
 
 }  // namespace dbus