Mojo JS bindings: code generator maps interface ptr and request to InterfacePtr and InterfaceReques…

mojo/public/tools/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."""
 
 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 44 matching lines @@
   if field.kind in mojom.PRIMITIVES:
     return _kind_to_javascript_default_value[field.kind]
   if mojom.IsStructKind(field.kind):
     return "null"
   if mojom.IsUnionKind(field.kind):
     return "null"
   if mojom.IsArrayKind(field.kind):
     return "null"
   if mojom.IsMapKind(field.kind):
     return "null"
-  if mojom.IsInterfaceKind(field.kind) or \
-     mojom.IsInterfaceRequestKind(field.kind):
-    return _kind_to_javascript_default_value[mojom.MSGPIPE]
+  if mojom.IsInterfaceKind(field.kind):
+    return "new %sPtr()" % JavaScriptType(field.kind)

[yzshen1, 2016/12/12 22:39:49]

Because FooPtr and InterfaceRequest objects have their own "invalid" state, I
always use that instead of "null" for null interface pointer / request that we
pass to the user code. On the other hand, when the user code passes us null
interface pointer / request, I allow both "null" and invalid FooPtr /
InterfaceRequest.

[Ken Rockot(use gerrit already), 2016/12/12 23:48:07]

Makes sense

+  if mojom.IsInterfaceRequestKind(field.kind):
+    return "new bindings.InterfaceRequest()"
   if mojom.IsAssociatedKind(field.kind):
     return "null"
   if mojom.IsEnumKind(field.kind):
     return "0"
   raise Exception("No valid default: %s" % field)
 
 
 def JavaScriptPayloadSize(packed):
   packed_fields = packed.packed_fields
   if not packed_fields:
@@ skipping 39 matching lines @@
         else "PointerTo"
     return "new codec.%s(%s)" % (pointer_type, JavaScriptType(kind))
   if mojom.IsUnionKind(kind):
     return JavaScriptType(kind)
   if mojom.IsArrayKind(kind):
     array_type = "NullableArrayOf" if mojom.IsNullableKind(kind) else "ArrayOf"
     array_length = "" if kind.length is None else ", %d" % kind.length
     element_type = ElementCodecType(kind.kind)
     return "new codec.%s(%s%s)" % (array_type, element_type, array_length)
   if mojom.IsInterfaceKind(kind):
-    return "codec.%s" % ("NullableInterface" if mojom.IsNullableKind(kind)
-        else "Interface")
+    return "new codec.%s(%sPtr)" % (
+        "NullableInterface" if mojom.IsNullableKind(kind) else "Interface",
+        JavaScriptType(kind))
   if mojom.IsInterfaceRequestKind(kind):
-    return CodecType(mojom.MSGPIPE)
+    return "codec.%s" % (
+        "NullableInterfaceRequest" if mojom.IsNullableKind(kind)
+                                   else "InterfaceRequest")
   if mojom.IsAssociatedInterfaceKind(kind):
     return "codec.AssociatedInterfaceNotSupported"
   if mojom.IsAssociatedInterfaceRequestKind(kind):
     return "codec.AssociatedInterfaceRequestNotSupported"
   if mojom.IsEnumKind(kind):
     return "new codec.Enum(%s)" % JavaScriptType(kind)
   if mojom.IsMapKind(kind):
     map_type = "NullableMapOf" if mojom.IsNullableKind(kind) else "MapOf"
     key_type = ElementCodecType(kind.key_kind)
     value_type = ElementCodecType(kind.value_kind)
     return "new codec.%s(%s, %s)" % (map_type, key_type, value_type)
   raise Exception("No codec type for %s" % kind)
 
 
 def ElementCodecType(kind):
   return "codec.PackedBool" if mojom.IsBoolKind(kind) else CodecType(kind)
 
 
 def JavaScriptDecodeSnippet(kind):
   if (kind in mojom.PRIMITIVES or mojom.IsUnionKind(kind) or
-      mojom.IsInterfaceKind(kind) or mojom.IsAssociatedKind(kind)):
+      mojom.IsAnyInterfaceKind(kind)):
     return "decodeStruct(%s)" % CodecType(kind)
   if mojom.IsStructKind(kind):
     return "decodeStructPointer(%s)" % JavaScriptType(kind)
   if mojom.IsMapKind(kind):
     return "decodeMapPointer(%s, %s)" % \
         (ElementCodecType(kind.key_kind), ElementCodecType(kind.value_kind))
   if mojom.IsArrayKind(kind) and mojom.IsBoolKind(kind.kind):
     return "decodeArrayPointer(codec.PackedBool)"
   if mojom.IsArrayKind(kind):
     return "decodeArrayPointer(%s)" % CodecType(kind.kind)
   if mojom.IsUnionKind(kind):
     return "decodeUnion(%s)" % CodecType(kind)
-  if mojom.IsInterfaceRequestKind(kind):
-    return JavaScriptDecodeSnippet(mojom.MSGPIPE)
   if mojom.IsEnumKind(kind):
     return JavaScriptDecodeSnippet(mojom.INT32)
   raise Exception("No decode snippet for %s" % kind)
 
 
 def JavaScriptEncodeSnippet(kind):
   if (kind in mojom.PRIMITIVES or mojom.IsUnionKind(kind) or
-      mojom.IsInterfaceKind(kind) or mojom.IsAssociatedKind(kind)):
+      mojom.IsAnyInterfaceKind(kind)):
     return "encodeStruct(%s, " % CodecType(kind)
   if mojom.IsUnionKind(kind):
     return "encodeStruct(%s, " % JavaScriptType(kind)
   if mojom.IsStructKind(kind):
     return "encodeStructPointer(%s, " % JavaScriptType(kind)
   if mojom.IsMapKind(kind):
     return "encodeMapPointer(%s, %s, " % \
         (ElementCodecType(kind.key_kind), ElementCodecType(kind.value_kind))
   if mojom.IsArrayKind(kind) and mojom.IsBoolKind(kind.kind):
     return "encodeArrayPointer(codec.PackedBool, ";
   if mojom.IsArrayKind(kind):
     return "encodeArrayPointer(%s, " % CodecType(kind.kind)
-  if mojom.IsInterfaceRequestKind(kind):
-    return JavaScriptEncodeSnippet(mojom.MSGPIPE)
   if mojom.IsEnumKind(kind):
     return JavaScriptEncodeSnippet(mojom.INT32)
   raise Exception("No encode snippet for %s" % kind)
 
 
 def JavaScriptUnionDecodeSnippet(kind):
   if mojom.IsUnionKind(kind):
     return "decodeStructPointer(%s)" % JavaScriptType(kind)
   return JavaScriptDecodeSnippet(kind)
 
@@ skipping 53 matching lines @@
 def JavaScriptValidateMapParams(field):
   nullable = JavaScriptNullableParam(field)
   keys_type = ElementCodecType(field.kind.key_kind)
   values_kind = field.kind.value_kind;
   values_type = ElementCodecType(values_kind)
   values_nullable = "true" if mojom.IsNullableKind(values_kind) else "false"
   return "%s, %s, %s, %s" % \
       (nullable, keys_type, values_type, values_nullable)
 
 
-def JavaScriptValidateStringParams(field):
-  nullable = JavaScriptNullableParam(field)
-  return "%s" % (nullable)
-
-
-def JavaScriptValidateHandleParams(field):
-  nullable = JavaScriptNullableParam(field)
-  return "%s" % (nullable)
-
-def JavaScriptValidateInterfaceParams(field):
-  return JavaScriptValidateHandleParams(field)
-
-def JavaScriptProxyMethodParameterValue(parameter):
-  name = parameter.name;
-  if (mojom.IsInterfaceKind(parameter.kind)):
-   type = JavaScriptType(parameter.kind)
-   return "core.isHandle(%s) ? %s : connection.bindImpl" \
-       "(%s, %s)" % (name, name, name, type)
-  if (mojom.IsInterfaceRequestKind(parameter.kind)):
-   type = JavaScriptType(parameter.kind.kind)
-   return "core.isHandle(%s) ? %s : connection.bindProxy" \
-       "(%s, %s)" % (name, name, name, type)
-  return name;
-
-
-def JavaScriptStubMethodParameterValue(parameter):
-  name = parameter.name;
-  if (mojom.IsInterfaceKind(parameter.kind)):
-   type = JavaScriptType(parameter.kind)
-   return "connection.bindHandleToProxy(%s, %s)" % (name, type)
-  if (mojom.IsInterfaceRequestKind(parameter.kind)):
-   type = JavaScriptType(parameter.kind.kind)
-   return "connection.bindHandleToStub(%s, %s)" % (name, type)
-  return name;
-
-
 def TranslateConstants(token):
   if isinstance(token, (mojom.EnumValue, mojom.NamedValue)):
     # Both variable and enum constants are constructed like:
     # NamespaceUid.Struct[.Enum].CONSTANT_NAME
     name = []
     if token.imported_from:
       name.append(token.imported_from["unique_name"])
     if token.parent_kind:
       name.append(token.parent_kind.name)
     if isinstance(token, mojom.EnumValue):
@@ skipping 70 matching lines @@
     "is_bool_field": IsBoolField,
     "is_enum_field": IsEnumField,
     "is_handle_field": IsHandleField,
     "is_interface_field": IsInterfaceField,
     "is_interface_request_field": IsInterfaceRequestField,
     "is_map_pointer_field": IsMapPointerField,
     "is_object_field": IsObjectField,
     "is_string_pointer_field": IsStringPointerField,
     "is_struct_pointer_field": IsStructPointerField,
     "is_union_field": IsUnionField,
-    "js_proxy_method_parameter_value": JavaScriptProxyMethodParameterValue,
-    "js_stub_method_parameter_value": JavaScriptStubMethodParameterValue,
     "js_type": JavaScriptType,
     "payload_size": JavaScriptPayloadSize,
     "stylize_method": generator.StudlyCapsToCamel,
     "union_decode_snippet": JavaScriptUnionDecodeSnippet,
     "union_encode_snippet": JavaScriptUnionEncodeSnippet,
     "validate_array_params": JavaScriptValidateArrayParams,
     "validate_enum_params": JavaScriptValidateEnumParams,
-    "validate_handle_params": JavaScriptValidateHandleParams,
-    "validate_interface_params": JavaScriptValidateInterfaceParams,
     "validate_map_params": JavaScriptValidateMapParams,
-    "validate_string_params": JavaScriptValidateStringParams,
+    "validate_nullable_params": JavaScriptNullableParam,
     "validate_struct_params": JavaScriptValidateStructParams,
     "validate_union_params": JavaScriptValidateUnionParams,
   }
 
   def GetParameters(self):
     return {
       "namespace": self.module.namespace,
       "imports": self.GetImports(),
       "kinds": self.module.kinds,
       "enums": self.module.enums,
@@ skipping 42 matching lines @@
     return self.module.imports
 
   def GetImportedInterfaces(self):
     interface_to_import = {};
     for each_import in self.module.imports:
       for each_interface in each_import["module"].interfaces:
         name = each_interface.name
         interface_to_import[name] = each_import["unique_name"] + "." + name
     return interface_to_import;