Upstream version 5.34.104.0

[platform/framework/web/crosswalk.git] / src / mojo / public / bindings / generators / mojom_js_generator.py

diff --git a/src/mojo/public/bindings/generators/mojom_js_generator.py b/src/mojo/public/bindings/generators/mojom_js_generator.py
index e18aa84..252e4ce 100644 (file)
--- a/src/mojo/public/bindings/generators/mojom_js_generator.py
+++ b/src/mojo/public/bindings/generators/mojom_js_generator.py
@@ -10,7 +10,6 @@ from generate import mojom_generator
 
 from generate.template_expander import UseJinja
 
-
 _kind_to_javascript_default_value = {
   mojom.BOOL:    "false",
   mojom.INT8:    "0",
@@ -33,18 +32,15 @@ _kind_to_javascript_default_value = {
 
 def JavaScriptDefaultValue(field):
   if field.default:
-    if isinstance(field.default, list):
-      # TODO(mpcomplete): This will need to be more sophisticated to support
-      # arrays of objects/arrays.
-      return "[" + ", ".join(field.default) + "]"
-    else:
-      return field.default
+    raise Exception("Default values should've been handled in jinja.")
   if field.kind in mojom.PRIMITIVES:
     return _kind_to_javascript_default_value[field.kind]
   if isinstance(field.kind, mojom.Struct):
     return "null";
   if isinstance(field.kind, mojom.Array):
     return "[]";
+  if isinstance(field.kind, mojom.Interface):
+    return _kind_to_javascript_default_value[mojom.MSGPIPE]
 
 
 def JavaScriptPayloadSize(packed):
@@ -84,6 +80,8 @@ def GetJavaScriptType(kind):
     return "new codec.PointerTo(%s)" % GetJavaScriptType(kind.name)
   if isinstance(kind, mojom.Array):
     return "new codec.ArrayOf(%s)" % GetJavaScriptType(kind.kind)
+  if isinstance(kind, mojom.Interface):
+    return GetJavaScriptType(mojom.MSGPIPE)
   return kind
 
 
@@ -114,6 +112,8 @@ def JavaScriptDecodeSnippet(kind):
     return "decodeStructPointer(%s)" % GetJavaScriptType(kind.name);
   if isinstance(kind, mojom.Array):
     return "decodeArrayPointer(%s)" % GetJavaScriptType(kind.kind);
+  if isinstance(kind, mojom.Interface):
+    return JavaScriptDecodeSnippet(mojom.MSGPIPE)
 
 
 _kind_to_javascript_encode_snippet = {
@@ -143,25 +143,105 @@ def JavaScriptEncodeSnippet(kind):
     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 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,
+    "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