Fix bug with using enums as default values in mojom. We were previously

mojo/public/bindings/generators/mojom_js_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 JavaScript source files from a mojom.Module."""
 
 from generate import mojom
 from generate import mojom_pack
 from generate import mojom_generator
 
 from generate.template_expander import UseJinja
 
-
 _kind_to_javascript_default_value = {
   mojom.BOOL:    "false",
   mojom.INT8:    "0",
   mojom.UINT8:   "0",
   mojom.INT16:   "0",
   mojom.UINT16:  "0",
   mojom.INT32:   "0",
   mojom.UINT32:  "0",
   mojom.FLOAT:   "0",
   mojom.HANDLE:  "core.kInvalidHandle",
@@ skipping 117 matching lines @@
   if kind in mojom.PRIMITIVES:
     return _kind_to_javascript_encode_snippet[kind]
   if isinstance(kind, mojom.Struct):
     return "encodeStructPointer(%s, " % GetJavaScriptType(kind.name);
   if isinstance(kind, mojom.Array):
     return "encodeArrayPointer(%s, " % GetJavaScriptType(kind.kind);
   if isinstance(kind, mojom.Interface):
     return JavaScriptEncodeSnippet(mojom.MSGPIPE)
 
 
-def SubstituteNamespace(value, imports):
-  for import_item in imports:
-    value = value.replace(import_item["namespace"] + ".",
-        import_item["unique_name"] + ".")
+def GetConstants(module):
+  """Returns a generator that enumerates all constants that can be referenced
+  from this module."""
+  class Constant:
+    pass
+
+  for enum in module.enums:
+    for field in enum.fields:
+      constant = Constant()
+      constant.namespace = module.namespace
+      constant.is_current_namespace = True
+      constant.import_item = None
+      constant.name = (enum.name, field.name)
+      yield constant
+
+  for each in module.imports:
+    for enum in each["module"].enums:
+      for field in enum.fields:
+        constant = Constant()
+        constant.namespace = each["namespace"]
+        constant.is_current_namespace = constant.namespace == module.namespace
+        constant.import_item = each
+        constant.name = (enum.name, field.name)
+        yield constant
+
+
+def TranslateConstants(value, module):
+  # We're assuming we're dealing with an identifier, but that may not be
+  # the case. If we're not, we just won't find any matches.
+  if value.find(".") != -1:
+    namespace, identifier = value.split(".")
+  else:
+    namespace, identifier = "", value
+
+  for constant in GetConstants(module):
+    if namespace == constant.namespace or (
+        namespace == "" and constant.is_current_namespace):
+      if constant.name[1] == identifier:
+        if constant.import_item:
+          return "%s.%s.%s" % (constant.import_item["unique_name"],
+              constant.name[0], constant.name[1])
+        else:
+          return "%s.%s" % (constant.name[0], constant.name[1])
   return value
 
 
+def ExpressionToText(value, module):
+  if value[0] != "EXPRESSION":
+    raise Exception("Expected EXPRESSION, got" + value)
+  return "".join(mojom_generator.ExpressionMapper(value,
+      lambda token: TranslateConstants(token, module)))
+
+
 def JavascriptType(kind):
   if kind.imported_from:
     return kind.imported_from["unique_name"] + "." + kind.name
   return kind.name
 
 
 class Generator(mojom_generator.Generator):
 
   js_filters = {
     "camel_to_underscores": mojom_generator.CamelToUnderscores,
     "default_value": JavaScriptDefaultValue,
     "payload_size": JavaScriptPayloadSize,
     "decode_snippet": JavaScriptDecodeSnippet,
     "encode_snippet": JavaScriptEncodeSnippet,
+    "expression_to_text": ExpressionToText,
     "is_object_kind": mojom_generator.IsObjectKind,
     "is_string_kind": mojom_generator.IsStringKind,
     "is_array_kind": lambda kind: isinstance(kind, mojom.Array),
     "js_type": JavascriptType,
     "stylize_method": mojom_generator.StudlyCapsToCamel,
-    "substitute_namespace": SubstituteNamespace,
     "verify_token_type": mojom_generator.VerifyTokenType,
   }
 
   @UseJinja("js_templates/module.js.tmpl", filters=js_filters)
   def GenerateJsModule(self):
     return {
       "imports": self.GetImports(),
       "kinds": self.module.kinds,
       "enums": self.module.enums,
+      "module": self.module,
       "structs": self.GetStructs() + self.GetStructsFromMethods(),
       "interfaces": self.module.interfaces,
     }
 
   def GenerateFiles(self):
     self.Write(self.GenerateJsModule(), "%s.js" % self.module.name)
 
   def GetImports(self):
     # Since each import is assigned a variable in JS, they need to have unique
     # names.
     counter = 1
     for each in self.module.imports:
       each["unique_name"] = "import" + str(counter)
       counter += 1
     return self.module.imports