headless: Make API generator more robust against weird enum literals

headless/lib/browser/type_conversions_h.template

 // This file is generated
 
 // 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.
 
 #ifndef HEADLESS_PUBLIC_DOMAINS_TYPE_CONVERSIONS_H_
 #define HEADLESS_PUBLIC_DOMAINS_TYPE_CONVERSIONS_H_
 
 #include "headless/public/domains/types.h"
 #include "headless/public/internal/value_conversions.h"
 
 namespace headless {
 namespace internal {
 
 {% for domain in api.domains %}
   {% for type in domain.types %}
     {% set namespace = domain.domain | camelcase_to_hacker_style %}
     {% if "enum" in type %}
 template <>
 struct FromValue<{{namespace}}::{{type.id}}> {
   static {{namespace}}::{{type.id}} Parse(const base::Value& value, ErrorReporter* errors) {
-      {% set default = namespace + '::' + type.id + '::' + type.enum[0] | dash_to_camelcase | camelcase_to_hacker_style | upper | mangle_enum %}
+      {% set default = namespace + '::' + type.id + '::' + type.enum[0] | sanitize_literal | dash_to_camelcase | camelcase_to_hacker_style | upper %}
     std::string string_value;
     if (!value.GetAsString(&string_value)) {
       errors->AddError("string enum value expected");
       {# Return an arbitrary enum member -- the caller will just ignore it. #}
       return {{default}};
     }
       {% for literal in type.enum %}
     if (string_value == "{{literal}}")
-      return {{namespace}}::{{type.id}}::{{literal | dash_to_camelcase | camelcase_to_hacker_style | upper | mangle_enum}};
+      return {{namespace}}::{{type.id}}::{{literal | sanitize_literal | dash_to_camelcase | camelcase_to_hacker_style | upper }};
       {% endfor %}
     errors->AddError("invalid enum value");
     return {{default}};
   }
 };
 
 template <typename T>
 std::unique_ptr<base::Value> ToValueImpl(const {{namespace}}::{{type.id}}& value, T*) {
   switch (value) {
       {% for literal in type.enum %}
-    case {{namespace}}::{{type.id}}::{{literal | dash_to_camelcase | camelcase_to_hacker_style | upper | mangle_enum}}:
+    case {{namespace}}::{{type.id}}::{{literal | sanitize_literal | dash_to_camelcase | camelcase_to_hacker_style | upper }}:
       return base::WrapUnique(new base::StringValue("{{literal}}"));
       {% endfor %}
   };
   NOTREACHED();
   return nullptr;
 }
       {% continue %}
     {% endif %}
 
     {% if not (type.type == "object") or not ("properties" in type) %}{% continue %}{% endif %}
@@ skipping 14 matching lines @@
 
 template <typename T>
 std::unique_ptr<base::Value> ToValue(const T& value) {
   return ToValueImpl(value, static_cast<T*>(nullptr));
 }
 
 }  // namespace internal
 }  // namespace headless
 
 #endif  // HEADLESS_PUBLIC_DOMAINS_TYPE_CONVERSIONS_H_