mojo: generate Proxies and Stubs for java bindings.

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

 # Copyright 2014 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 java source files from a mojom.Module."""
 
 import argparse
 import ast
 import os
 import re
@@ skipping 185 matching lines @@
     return _java_primitive_to_boxed_type[unboxed_type]
   return unboxed_type
 
 @contextfilter
 def GetJavaType(context, kind, boxed=False):
   if boxed:
     return GetBoxedJavaType(context, kind)
   if mojom.IsStructKind(kind) or mojom.IsInterfaceKind(kind):
     return GetNameForKind(context, kind)
   if mojom.IsInterfaceRequestKind(kind):
-    return ("org.chromium.mojo.bindings.InterfaceRequest<%s>" %
+    return ("org.chromium.mojo.bindings.InterfaceRequest<%s.Proxy>" %
             GetNameForKind(context, kind.kind))
   if mojom.IsAnyArrayKind(kind):
     return "%s[]" % GetJavaType(context, kind.kind)
   if mojom.IsEnumKind(kind):
     return "int"
   return _spec_to_java_type[kind.spec]
 
 @contextfilter
 def DefaultValue(context, field):
   assert field.default
@@ skipping 44 matching lines @@
       number -= 2 ** 64
     return '%dL' % number
   return token
 
 def IsPointerArrayKind(kind):
   if not mojom.IsAnyArrayKind(kind):
     return False
   sub_kind = kind.kind
   return mojom.IsObjectKind(sub_kind)
 
+def GetResponseStructFromMethod(method):
+  return generator.GetDataHeader(
+      False, generator.GetResponseStructFromMethod(method))
+
+def GetStructFromMethod(method):
+  return generator.GetDataHeader(
+      False, generator.GetStructFromMethod(method))
+
 def GetConstantsMainEntityName(module):
   if 'JavaConstantsClassName' in module.attributes:
     return ParseStringAttribute(module.attributes['JavaConstantsClassName'])
   # This constructs the name of the embedding classes for module level constants
   # by extracting the mojom's filename and prepending it to Constants.
   return (UpperCamelCase(module.path.split('/')[-1].rsplit('.', 1)[0]) +
           'Constants')
 
+def GetMethodOrdinalName(method):
+  return ConstantStyle(method.name) + "_ORDINAL"
+
+def HasMethodWithResponse(interface):
+  for method in interface.methods:
+    if method.response_parameters:
+      return True
+  return False
+
+def HasMethodWithoutResponse(interface):
+  for method in interface.methods:
+    if not method.response_parameters:
+      return True
+  return False
+
 class Generator(generator.Generator):
 
   java_filters = {
     "interface_response_name": GetInterfaceResponseName,
     "constant_value": ConstantValue,
     "default_value": DefaultValue,
     "decode_method": DecodeMethod,
     "expression_to_text": ExpressionToText,
     "encode_method": EncodeMethod,
+    "has_method_with_response": HasMethodWithResponse,
+    "has_method_without_response": HasMethodWithoutResponse,
     "is_handle": mojom.IsNonInterfaceHandleKind,
     "is_pointer_array_kind": IsPointerArrayKind,
     "is_struct_kind": mojom.IsStructKind,
     "java_type": GetJavaType,
+    "method_ordinal_name": GetMethodOrdinalName,
     "name": GetNameForElement,
     "new_array": NewArray,
+    "response_struct_from_method": GetResponseStructFromMethod,
+    "struct_from_method": GetStructFromMethod,
     "struct_size": lambda ps: ps.GetTotalSize() + _HEADER_SIZE,
   }
 
   def GetJinjaExports(self):
     return {
       "module": self.module,
       "package": GetPackage(self.module),
     }
 
+  def GetJinjaExportsForInterface(self, interface):
+    exports = self.GetJinjaExports()
+    exports.update({"interface": interface})
+    if interface.client:
+      for client in self.module.interfaces:
+        if client.name == interface.client:
+          exports.update({"client": client})
+    return exports
+
   @UseJinja("java_templates/enum.java.tmpl", filters=java_filters)
   def GenerateEnumSource(self, enum):
     exports = self.GetJinjaExports()
     exports.update({"enum": enum})
     return exports
 
   @UseJinja("java_templates/struct.java.tmpl", filters=java_filters)
   def GenerateStructSource(self, struct):
     exports = self.GetJinjaExports()
     exports.update({"struct": struct})
     return exports
 
   @UseJinja("java_templates/interface.java.tmpl", filters=java_filters)
   def GenerateInterfaceSource(self, interface):
-    exports = self.GetJinjaExports()
-    exports.update({"interface": interface})
-    if interface.client:
-      for client in self.module.interfaces:
-        if client.name == interface.client:
-          exports.update({"client": client})
-    return exports
+    return self.GetJinjaExportsForInterface(interface)
+
+  @UseJinja("java_templates/interface_internal.java.tmpl", filters=java_filters)
+  def GenerateInterfaceInternalSource(self, interface):
+    return self.GetJinjaExportsForInterface(interface)
 
   @UseJinja("java_templates/constants.java.tmpl", filters=java_filters)
   def GenerateConstantsSource(self, module):
     exports = self.GetJinjaExports()
     exports.update({"main_entity": GetConstantsMainEntityName(module),
                     "constants": module.constants})
     return exports
 
   def GenerateFiles(self, unparsed_args):
     parser = argparse.ArgumentParser()
@@ skipping 13 matching lines @@
       self.Write(self.GenerateEnumSource(enum),
                  "%s.java" % GetNameForElement(enum))
 
     for struct in self.module.structs:
       self.Write(self.GenerateStructSource(struct),
                  "%s.java" % GetNameForElement(struct))
 
     for interface in self.module.interfaces:
       self.Write(self.GenerateInterfaceSource(interface),
                  "%s.java" % GetNameForElement(interface))
+      self.Write(self.GenerateInterfaceInternalSource(interface),
+                 "%sInternal.java" % GetNameForElement(interface))
 
     if self.module.constants:
       self.Write(self.GenerateConstantsSource(self.module),
                  "%s.java" % GetConstantsMainEntityName(self.module))
 
   def GetJinjaParameters(self):
     return {
       'lstrip_blocks': True,
       'trim_blocks': True,
     }
 
   def GetGlobals(self):
     return {
       'module': self.module,
     }