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

content/browser/accessibility/accessibility_tree_formatter_win.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 "content/browser/accessibility/accessibility_tree_formatter.h"
 
 #include <oleacc.h>
 #include <stddef.h>
 #include <stdint.h>
 
@@ skipping 331 matching lines @@
   base::string16 role_value;
   dict.GetString("role", &role_value);
   WriteAttribute(true, base::UTF16ToUTF8(role_value), &line);
 
   for (const char* attribute_name : ALL_ATTRIBUTES) {
     const base::Value* value;
     if (!dict.Get(attribute_name, &value))
       continue;
 
     switch (value->GetType()) {
-      case base::Value::TYPE_STRING: {
+      case base::Value::Type::STRING: {
         base::string16 string_value;
         value->GetAsString(&string_value);
         WriteAttribute(false,
                        base::StringPrintf(L"%ls='%ls'",
                                     base::UTF8ToUTF16(attribute_name).c_str(),
                                     string_value.c_str()),
                        &line);
         break;
       }
-      case base::Value::TYPE_INTEGER: {
+      case base::Value::Type::INTEGER: {
         int int_value = 0;
         value->GetAsInteger(&int_value);
         WriteAttribute(false,
                        base::StringPrintf(L"%ls=%d",
                                           base::UTF8ToUTF16(
                                               attribute_name).c_str(),
                                           int_value),
                        &line);
         break;
       }
-      case base::Value::TYPE_DOUBLE: {
+      case base::Value::Type::DOUBLE: {
         double double_value = 0.0;
         value->GetAsDouble(&double_value);
         WriteAttribute(false,
                        base::StringPrintf(L"%ls=%.2f",
                                           base::UTF8ToUTF16(
                                               attribute_name).c_str(),
                                           double_value),
                        &line);
         break;
       }
-      case base::Value::TYPE_LIST: {
+      case base::Value::Type::LIST: {
         // Currently all list values are string and are written without
         // attribute names.
         const base::ListValue* list_value;
         value->GetAsList(&list_value);
         for (base::ListValue::const_iterator it = list_value->begin();
              it != list_value->end();
              ++it) {
           base::string16 string_value;
           if ((*it)->GetAsString(&string_value))
             WriteAttribute(false, string_value, &line);
         }
         break;
       }
-      case base::Value::TYPE_DICTIONARY: {
+      case base::Value::Type::DICTIONARY: {
         // Currently all dictionary values are coordinates.
         // Revisit this if that changes.
         const base::DictionaryValue* dict_value;
         value->GetAsDictionary(&dict_value);
         if (strcmp(attribute_name, "size") == 0) {
           WriteAttribute(false,
                          FormatCoordinates("size", "width", "height",
                                            *dict_value),
                          &line);
         } else if (strcmp(attribute_name, "location") == 0) {
@@ skipping 23 matching lines @@
 
 const std::string AccessibilityTreeFormatterWin::GetAllowString() {
   return "@WIN-ALLOW:";
 }
 
 const std::string AccessibilityTreeFormatterWin::GetDenyString() {
   return "@WIN-DENY:";
 }
 
 }  // namespace content