Update to Chromium //base at Chromium commit e3a753f17bac62738b0dbf0b36510f767b081e4b.

android/jni_generator/jni_generator.py

 #!/usr/bin/env python
 # Copyright (c) 2012 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.
 
 """Extracts native methods from a Java file and generates the JNI bindings.
 If you change this, please run and update the tests."""
 
 import collections
 import errno
@@ skipping 117 matching lines @@
       return java_pod_type_map[java_type[:-2]] + 'Array'
     return 'jobjectArray'
   elif java_type.startswith('Class'):
     # Checking just the start of the name, rather than a direct comparison,
     # in order to handle generics.
     return 'jclass'
   else:
     return 'jobject'
 
 
+def WrapCTypeForDeclaration(c_type):
+  """Wrap the C datatype in a JavaRef if required."""
+  if re.match(RE_SCOPED_JNI_TYPES, c_type):
+    return 'const JavaParamRef<' + c_type + '>&'
+  else:
+    return c_type
+
+
+def JavaDataTypeToCForDeclaration(java_type):
+  """Returns a JavaRef-wrapped C datatype for the given java type."""
+  return WrapCTypeForDeclaration(JavaDataTypeToC(java_type))
+
+
 def JavaDataTypeToCForCalledByNativeParam(java_type):
   """Returns a C datatype to be when calling from native."""
   if java_type == 'int':
     return 'JniIntWrapper'
   else:
     return JavaDataTypeToC(java_type)
 
 
 def JavaReturnValueToC(java_type):
   """Returns a valid C return value for the given java type."""
@@ skipping 372 matching lines @@
     method_name = called_by_native.name
     method_id_var_name = method_name
     if method_counts[java_class_name][method_name] > 1:
       method_id_var_name = GetMangledMethodName(method_name,
                                                 called_by_native.params,
                                                 called_by_native.return_type)
     called_by_native.method_id_var_name = method_id_var_name
   return called_by_natives
 
 
-# Regex to match the JNI return types that should be included in a
-# ScopedJavaLocalRef.
-RE_SCOPED_JNI_RETURN_TYPES = re.compile(
-    'jobject|jclass|jstring|jthrowable|.*Array')
+# Regex to match the JNI types that should be wrapped in a JavaRef.
+RE_SCOPED_JNI_TYPES = re.compile('jobject|jclass|jstring|jthrowable|.*Array')
+
 
 # Regex to match a string like "@CalledByNative public void foo(int bar)".
 RE_CALLED_BY_NATIVE = re.compile(
     '@CalledByNative(?P<Unchecked>(Unchecked)*?)(?:\("(?P<annotation>.*)"\))?'
     '\s+(?P<prefix>[\w ]*?)'
     '\s*(?P<return_type>\S+?)'
     '\s+(?P<name>\w+)'
     '\s*\((?P<params>[^\)]*)\)')
 
 
@@ skipping 454 matching lines @@
     return ''
 
   def GetCloseNamespaceString(self):
     if self.namespace:
       all_namespaces = ['}  // namespace %s' % ns
                         for ns in self.namespace.split('::')]
       all_namespaces.reverse()
       return '\n'.join(all_namespaces) + '\n'
     return ''
 
-  def GetJNIFirstParam(self, native):
-    ret = []
+  def GetJNIFirstParamType(self, native):
     if native.type == 'method':
-      ret = ['jobject jcaller']
+      return 'jobject'
     elif native.type == 'function':
       if native.static:
-        ret = ['jclass jcaller']
+        return 'jclass'
       else:
-        ret = ['jobject jcaller']
-    return ret
+        return 'jobject'
+
+  def GetJNIFirstParam(self, native, for_declaration):
+    c_type = self.GetJNIFirstParamType(native)
+    if for_declaration:
+      c_type = WrapCTypeForDeclaration(c_type)
+    return [c_type + ' jcaller']
 
   def GetParamsInDeclaration(self, native):
+    """Returns the params for the forward declaration.
+
+    Args:
+      native: the native dictionary describing the method.
+
+    Returns:
+      A string containing the params.
+    """
+    return ',\n    '.join(self.GetJNIFirstParam(native, True) +
+                          [JavaDataTypeToCForDeclaration(param.datatype) + ' ' +
+                           param.name
+                           for param in native.params])
+
+  def GetParamsInStub(self, native):
     """Returns the params for the stub declaration.
 
     Args:
       native: the native dictionary describing the method.
 
     Returns:
       A string containing the params.
     """
-    return ',\n    '.join(self.GetJNIFirstParam(native) +
+    return ',\n    '.join(self.GetJNIFirstParam(native, False) +
                           [JavaDataTypeToC(param.datatype) + ' ' +
                            param.name
                            for param in native.params])
 
   def GetCalledByNativeParamsInDeclaration(self, called_by_native):
     return ',\n    '.join([
         JavaDataTypeToCForCalledByNativeParam(param.datatype) + ' ' +
         param.name
         for param in called_by_native.params])
 
@@ skipping 10 matching lines @@
 
     java_name = JniParams.RemapClassName(self.fully_qualified_class)
     java_name = java_name.replace('_', '_1').replace('/', '_')
     if native.java_class_name:
       java_name += '_00024' + native.java_class_name
 
     values = {'NAME': native.name,
               'JAVA_NAME': java_name}
     return template.substitute(values)
 
+  def GetJavaParamRefForCall(self, c_type, name):
+    return Template('JavaParamRef<${TYPE}>(env, ${NAME})').substitute({
+        'TYPE': c_type,
+        'NAME': name,
+    })
+
+  def GetJNIFirstParamForCall(self, native):
+    c_type = self.GetJNIFirstParamType(native)
+    return [self.GetJavaParamRefForCall(c_type, 'jcaller')]
+
   def GetNativeStub(self, native):
     is_method = native.type == 'method'
 
     if is_method:
       params = native.params[1:]
     else:
       params = native.params
     params_in_call = []
     if not self.options.pure_native_methods:
-      params_in_call = ['env', 'jcaller']
-    params_in_call = ', '.join(params_in_call + [p.name for p in params])
+      params_in_call = ['env'] + self.GetJNIFirstParamForCall(native)
+    for p in params:
+      c_type = JavaDataTypeToC(p.datatype)
+      if re.match(RE_SCOPED_JNI_TYPES, c_type):
+        params_in_call.append(self.GetJavaParamRefForCall(c_type, p.name))
+      else:
+        params_in_call.append(p.name)
+    params_in_call = ', '.join(params_in_call)
 
     if self.options.native_exports:
       stub_visibility = 'extern "C" __attribute__((visibility("default")))\n'
     else:
       stub_visibility = 'static '
     return_type = return_declaration = JavaDataTypeToC(native.return_type)
     post_call = ''
-    if re.match(RE_SCOPED_JNI_RETURN_TYPES, return_type):
+    if re.match(RE_SCOPED_JNI_TYPES, return_type):
       post_call = '.Release()'
       return_declaration = 'ScopedJavaLocalRef<' + return_type + '>'
     values = {
         'RETURN': return_type,
         'RETURN_DECLARATION': return_declaration,
         'NAME': native.name,
         'PARAMS': self.GetParamsInDeclaration(native),
+        'PARAMS_IN_STUB': self.GetParamsInStub(native),
         'PARAMS_IN_CALL': params_in_call,
         'POST_CALL': post_call,
         'STUB_NAME': self.GetStubName(native),
         'STUB_VISIBILITY': stub_visibility,
     }
 
     if is_method:
       optional_error_return = JavaReturnValueToC(native.return_type)
       if optional_error_return:
         optional_error_return = ', ' + optional_error_return
       values.update({
           'OPTIONAL_ERROR_RETURN': optional_error_return,
           'PARAM0_NAME': native.params[0].name,
           'P0_TYPE': native.p0_type,
       })
       template = Template("""\
 ${STUB_VISIBILITY}${RETURN} ${STUB_NAME}(JNIEnv* env,
-    ${PARAMS}) {
+    ${PARAMS_IN_STUB}) {
   ${P0_TYPE}* native = reinterpret_cast<${P0_TYPE}*>(${PARAM0_NAME});
   CHECK_NATIVE_PTR(env, jcaller, native, "${NAME}"${OPTIONAL_ERROR_RETURN});
   return native->${NAME}(${PARAMS_IN_CALL})${POST_CALL};
 }
 """)
     else:
       template = Template("""
 static ${RETURN_DECLARATION} ${NAME}(JNIEnv* env, ${PARAMS});
 
-${STUB_VISIBILITY}${RETURN} ${STUB_NAME}(JNIEnv* env, ${PARAMS}) {
+${STUB_VISIBILITY}${RETURN} ${STUB_NAME}(JNIEnv* env, ${PARAMS_IN_STUB}) {
   return ${NAME}(${PARAMS_IN_CALL})${POST_CALL};
 }
 """)
 
     return template.substitute(values)
 
   def GetArgument(self, param):
     return ('as_jint(' + param.name + ')'
             if param.datatype == 'int' else param.name)
 
@@ skipping 27 matching lines @@
       check_exception = 'jni_generator::CheckException(env);'
     return_type = JavaDataTypeToC(called_by_native.return_type)
     optional_error_return = JavaReturnValueToC(called_by_native.return_type)
     if optional_error_return:
       optional_error_return = ', ' + optional_error_return
     return_declaration = ''
     return_clause = ''
     if return_type != 'void':
       pre_call = ' ' + pre_call
       return_declaration = return_type + ' ret ='
-      if re.match(RE_SCOPED_JNI_RETURN_TYPES, return_type):
+      if re.match(RE_SCOPED_JNI_TYPES, return_type):
         return_type = 'ScopedJavaLocalRef<' + return_type + '>'
         return_clause = 'return ' + return_type + '(env, ret);'
       else:
         return_clause = 'return ret;'
     return {
         'JAVA_CLASS': java_class,
         'RETURN_TYPE': return_type,
         'OPTIONAL_ERROR_RETURN': optional_error_return,
         'RETURN_DECLARATION': return_declaration,
         'RETURN_CLAUSE': return_clause,
@@ skipping 357 matching lines @@
   GenerateJNIHeader(input_file, output_file, options)
 
   if options.depfile:
     build_utils.WriteDepfile(
         options.depfile,
         build_utils.GetPythonDependencies())
 
 
 if __name__ == '__main__':
   sys.exit(main(sys.argv))