Docserver: Display enum value descriptions in API docs.

components/json_schema/json_schema_validator.cc

 // Copyright 2013 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/json_schema/json_schema_validator.h"
 
 #include <algorithm>
 #include <cfloat>
 #include <cmath>
 
@@ skipping 35 matching lines @@
 struct ExpectedType {
   const char* key;
   base::Value::Type type;
 };
 
 // Helper for std::lower_bound.
 bool CompareToString(const ExpectedType& entry, const std::string& key) {
   return entry.key < key;
 }
 
+// If |value| is a dictionary, returns the "name" attribute of |value| or NULL
+// if |value| does not contain a "name" attribute. Otherwise, returns |value|.
+const base::Value* ExtractNameFromDictionary(const base::Value* value) {
+  const base::DictionaryValue* value_dict = NULL;
+  const base::Value* name_value = NULL;
+  if (value->GetAsDictionary(&value_dict)) {
+    value_dict->Get("name", &name_value);
+    return name_value;
+  }
+  return value;
+}
+
 bool IsValidSchema(const base::DictionaryValue* dict, std::string* error) {
   // This array must be sorted, so that std::lower_bound can perform a
   // binary search.
   static const ExpectedType kExpectedTypes[] = {
     // Note: kRef == "$ref", kSchema == "$schema"
     { schema::kRef,                     base::Value::TYPE_STRING      },
     { schema::kSchema,                  base::Value::TYPE_STRING      },
 
     { schema::kAdditionalProperties,    base::Value::TYPE_DICTIONARY  },
     { schema::kChoices,                 base::Value::TYPE_LIST        },
@@ skipping 122 matching lines @@
         return false;
       }
     }
 
     // Validate the values contained in an "enum" attribute.
     if (it.key() == schema::kEnum) {
       it.value().GetAsList(&list_value);
       for (size_t i = 0; i < list_value->GetSize(); ++i) {
         const base::Value* value = NULL;
         list_value->Get(i, &value);
+        // Sometimes the enum declaration is a dictionary with the enum value
+        // under "name".
+        value = ExtractNameFromDictionary(value);
+        if (!value) {
+          *error = "Invalid value in enum attribute";
+          return false;
+        }
         switch (value->GetType()) {
           case base::Value::TYPE_NULL:
           case base::Value::TYPE_BOOLEAN:
           case base::Value::TYPE_INTEGER:
           case base::Value::TYPE_DOUBLE:
           case base::Value::TYPE_STRING:
             break;
           default:
             *error = "Invalid value in enum attribute";
             return false;
@@ skipping 264 matching lines @@
   errors_.push_back(Error(path, kInvalidChoice));
   return;
 }
 
 void JSONSchemaValidator::ValidateEnum(const base::Value* instance,
                                        const base::ListValue* choices,
                                        const std::string& path) {
   for (size_t i = 0; i < choices->GetSize(); ++i) {
     const base::Value* choice = NULL;
     CHECK(choices->Get(i, &choice));
+    // Sometimes the enum declaration is a dictionary with the enum value under
+    // "name".
+    choice = ExtractNameFromDictionary(choice);
+    if (!choice) {
+      NOTREACHED();
+    }
     switch (choice->GetType()) {
       case base::Value::TYPE_NULL:
       case base::Value::TYPE_BOOLEAN:
       case base::Value::TYPE_STRING:
         if (instance->Equals(choice))
           return;
         break;
 
       case base::Value::TYPE_INTEGER:
       case base::Value::TYPE_DOUBLE:
@@ skipping 226 matching lines @@
 
   if (*additional_properties_schema) {
     std::string additional_properties_type(schema::kAny);
     CHECK((*additional_properties_schema)->GetString(
         schema::kType, &additional_properties_type));
     return additional_properties_type == schema::kAny;
   } else {
     return default_allow_additional_properties_;
   }
 }