For c++, Generate enum classes instead of enum from mojom.

mojo/public/tools/bindings/generators/mojom_cpp_generator.py

 # 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.
 
 """Generates C++ source files from a mojom.Module."""
 
 import mojom.generate.generator as generator
 import mojom.generate.module as mojom
 import mojom.generate.pack as pack
 from mojom.generate.template_expander import UseJinja
@@ skipping 35 matching lines @@
   return ExpressionToText(constant.value, kind=constant.kind)
 
 def DefaultValue(field):
   if field.default:
     if mojom.IsStructKind(field.kind):
       assert field.default == "default"
       return "%s::New()" % GetNameForKind(field.kind)
     return ExpressionToText(field.default, kind=field.kind)
   return ""
 
+def IsEnumToken(token):
+  return isinstance(token, mojom.EnumValue)
+
 def NamespaceToArray(namespace):
   return namespace.split(".") if namespace else []
 
 def GetNameForKind(kind, internal = False):
   parts = []
   if kind.imported_from:
     parts.extend(NamespaceToArray(kind.imported_from["namespace"]))
   if internal:
     parts.append("internal")
   if kind.parent_kind:
@@ skipping 192 matching lines @@
 def TranslateConstants(token, kind):
   if isinstance(token, mojom.NamedValue):
     # Both variable and enum constants are constructed like:
     # Namespace::Struct::CONSTANT_NAME
     # For enums, CONSTANT_NAME is ENUM_NAME_ENUM_VALUE.
     name = []
     if token.imported_from:
       name.extend(NamespaceToArray(token.namespace))
     if token.parent_kind:
       name.append(token.parent_kind.name)
-    if isinstance(token, mojom.EnumValue):
-      name.append(
-          "%s_%s" % (generator.CamelCaseToAllCaps(token.enum.name), token.name))
+    if IsEnumToken(token):
+      name.extend([token.enum.name, token.name])
     else:
       name.append(token.name)
-    return "::".join(name)
+
+    ret = "::".join(name)
+
+    # If we are translating an enum token for a non-enum (but defined) kind, or
+    # a non-enum token for an enum kind, we need an explicit cast.
+    # TODO(johngro) : should this be allowed at all?
+    if IsEnumToken(token) and kind is not None and not mojom.IsEnumKind(kind):
+      return "static_cast<int32_t>(%s)" % (ret, )
+    elif not IsEnumToken(token) and mojom.IsEnumKind(kind):
+      return "static_cast<%s>(%s)" % (GetNameForKind(kind), ret)
+    return ret
 
   if isinstance(token, mojom.BuiltinValue):
     if token.value == "double.INFINITY" or token.value == "float.INFINITY":
       return "INFINITY";
     if token.value == "double.NEGATIVE_INFINITY" or \
        token.value == "float.NEGATIVE_INFINITY":
       return "-INFINITY";
     if token.value == "double.NAN" or token.value == "float.NAN":
       return "NAN";
 
   if (kind is not None and mojom.IsFloatKind(kind)):
       return token if token.isdigit() else token + "f";
 
   # Per C++11, 2.14.2, the type of an integer literal is the first of the
   # corresponding list in Table 6 in which its value can be represented. In this
   # case, the list for decimal constants with no suffix is:
   #   int, long int, long long int
   # The standard considers a program ill-formed if it contains an integer
   # literal that cannot be represented by any of the allowed types.
   #
   # As it turns out, MSVC doesn't bother trying to fall back to long long int,
   # so the integral constant -2147483648 causes it grief: it decides to
   # represent 2147483648 as an unsigned integer, and then warns that the unary
   # minus operator doesn't make sense on unsigned types. Doh!
   if kind == mojom.INT32 and token == "-2147483648":
     return "(-%d - 1) /* %s */" % (
         2**31 - 1, "Workaround for MSVC bug; see https://crbug.com/445618")
 
-  return "%s%s" % (token, _kind_to_cpp_literal_suffix.get(kind, ""))
+
+  # If we are translating a literal for an enum kind, we need an explicit cast.
+  # TODO(johngro) : should this be allowed at all?
+  ret = "%s%s" % (token, _kind_to_cpp_literal_suffix.get(kind, ""))
+  if mojom.IsEnumKind(kind):
+      return "static_cast<%s>(%s)" % (GetNameForKind(kind), ret)
+  return ret
 
 def ExpressionToText(value, kind=None):
   return TranslateConstants(value, kind)
 
 def ShouldInlineStruct(struct):
   # TODO(darin): Base this on the size of the wrapper class.
   if len(struct.fields) > 4:
     return False
   for field in struct.fields:
     if mojom.IsMoveOnlyKind(field.kind):
@@ skipping 102 matching lines @@
   def GenerateModuleSource(self):
     return self.GetJinjaExports()
 
   def GenerateFiles(self, args):
     self.Write(self.GenerateModuleHeader(),
         self.MatchMojomFilePath("%s.h" % self.module.name))
     self.Write(self.GenerateModuleInternalHeader(),
         self.MatchMojomFilePath("%s-internal.h" % self.module.name))
     self.Write(self.GenerateModuleSource(),
         self.MatchMojomFilePath("%s.cc" % self.module.name))