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

base/json/json_writer.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 "base/json/json_writer.h"
 
 #include <stdint.h>
 
 #include <cmath>
 #include <limits>
@@ skipping 39 matching lines @@
     : omit_binary_values_((options & OPTIONS_OMIT_BINARY_VALUES) != 0),
       omit_double_type_preservation_(
           (options & OPTIONS_OMIT_DOUBLE_TYPE_PRESERVATION) != 0),
       pretty_print_((options & OPTIONS_PRETTY_PRINT) != 0),
       json_string_(json) {
   DCHECK(json);
 }
 
 bool JSONWriter::BuildJSONString(const Value& node, size_t depth) {
   switch (node.GetType()) {
-    case Value::TYPE_NULL: {
+    case Value::Type::NONE: {
       json_string_->append("null");
       return true;
     }
 
-    case Value::TYPE_BOOLEAN: {
+    case Value::Type::BOOLEAN: {
       bool value;
       bool result = node.GetAsBoolean(&value);
       DCHECK(result);
       json_string_->append(value ? "true" : "false");
       return result;
     }
 
-    case Value::TYPE_INTEGER: {
+    case Value::Type::INTEGER: {
       int value;
       bool result = node.GetAsInteger(&value);
       DCHECK(result);
       json_string_->append(IntToString(value));
       return result;
     }
 
-    case Value::TYPE_DOUBLE: {
+    case Value::Type::DOUBLE: {
       double value;
       bool result = node.GetAsDouble(&value);
       DCHECK(result);
       if (omit_double_type_preservation_ &&
           value <= std::numeric_limits<int64_t>::max() &&
           value >= std::numeric_limits<int64_t>::min() &&
           std::floor(value) == value) {
         json_string_->append(Int64ToString(static_cast<int64_t>(value)));
         return result;
       }
@@ skipping 11 matching lines @@
       if (real[0] == '.') {
         real.insert(static_cast<size_t>(0), static_cast<size_t>(1), '0');
       } else if (real.length() > 1 && real[0] == '-' && real[1] == '.') {
         // "-.1" bad "-0.1" good
         real.insert(static_cast<size_t>(1), static_cast<size_t>(1), '0');
       }
       json_string_->append(real);
       return result;
     }
 
-    case Value::TYPE_STRING: {
+    case Value::Type::STRING: {
       std::string value;
       bool result = node.GetAsString(&value);
       DCHECK(result);
       EscapeJSONString(value, true, json_string_);
       return result;
     }
 
-    case Value::TYPE_LIST: {
+    case Value::Type::LIST: {
       json_string_->push_back('[');
       if (pretty_print_)
         json_string_->push_back(' ');
 
       const ListValue* list = NULL;
       bool first_value_has_been_output = false;
       bool result = node.GetAsList(&list);
       DCHECK(result);
       for (const auto& value : *list) {
-        if (omit_binary_values_ && value->GetType() == Value::TYPE_BINARY)
+        if (omit_binary_values_ && value->GetType() == Value::Type::BINARY)
           continue;
 
         if (first_value_has_been_output) {
           json_string_->push_back(',');
           if (pretty_print_)
             json_string_->push_back(' ');
         }
 
         if (!BuildJSONString(*value, depth))
           result = false;
 
         first_value_has_been_output = true;
       }
 
       if (pretty_print_)
         json_string_->push_back(' ');
       json_string_->push_back(']');
       return result;
     }
 
-    case Value::TYPE_DICTIONARY: {
+    case Value::Type::DICTIONARY: {
       json_string_->push_back('{');
       if (pretty_print_)
         json_string_->append(kPrettyPrintLineEnding);
 
       const DictionaryValue* dict = NULL;
       bool first_value_has_been_output = false;
       bool result = node.GetAsDictionary(&dict);
       DCHECK(result);
       for (DictionaryValue::Iterator itr(*dict); !itr.IsAtEnd();
            itr.Advance()) {
         if (omit_binary_values_ &&
-            itr.value().GetType() == Value::TYPE_BINARY) {
+            itr.value().GetType() == Value::Type::BINARY) {
           continue;
         }
 
         if (first_value_has_been_output) {
           json_string_->push_back(',');
           if (pretty_print_)
             json_string_->append(kPrettyPrintLineEnding);
         }
 
         if (pretty_print_)
@@ skipping 12 matching lines @@
 
       if (pretty_print_) {
         json_string_->append(kPrettyPrintLineEnding);
         IndentLine(depth);
       }
 
       json_string_->push_back('}');
       return result;
     }
 
-    case Value::TYPE_BINARY:
+    case Value::Type::BINARY:
       // Successful only if we're allowed to omit it.
       DLOG_IF(ERROR, !omit_binary_values_) << "Cannot serialize binary value.";
       return omit_binary_values_;
   }
   NOTREACHED();
   return false;
 }
 
 void JSONWriter::IndentLine(size_t depth) {
   json_string_->append(depth * 3U, ' ');
 }
 
 }  // namespace base