Catch intptr_t to int conversion on 64-bit platforms.

base/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 106 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 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."""
   java_pod_type_map = {
       'int': '0',
       'byte': '0',
       'char': '0',
       'short': '0',
       'boolean': 'false',
       'long': '0',
       'double': '0',
@@ skipping 528 matching lines @@
 // For
 //     ${FULLY_QUALIFIED_CLASS}
 
 #ifndef ${HEADER_GUARD}
 #define ${HEADER_GUARD}
 
 #include <jni.h>
 
 ${INCLUDES}
 
+#include "base/android/jni_int_wrapper.h"
+
 // Step 1: forward declarations.
 namespace {
 $CLASS_PATH_DEFINITIONS
 $METHOD_ID_DEFINITIONS
 }  // namespace
 
 $OPEN_NAMESPACE
 $FORWARD_DECLARATIONS
 
 $CONSTANT_FIELDS
@@ skipping 240 matching lines @@
 
     Returns:
       A string containing the params.
     """
     return ',\n    '.join(self.GetJNIFirstParam(native) +
                           [JavaDataTypeToC(param.datatype) + ' ' +
                            param.name
                            for param in native.params])
 
   def GetCalledByNativeParamsInDeclaration(self, called_by_native):
-    return ',\n    '.join([JavaDataTypeToC(param.datatype) + ' ' +
-                           param.name
-                           for param in called_by_native.params])
+    return ',\n    '.join([
+        JavaDataTypeToCForCalledByNativeParam(param.datatype) + ' ' +
+        param.name
+        for param in called_by_native.params])
 
   def GetForwardDeclaration(self, native):
     template = Template("""
 static ${RETURN} ${NAME}(JNIEnv* env, ${PARAMS});
 """)
     values = {'RETURN': JavaDataTypeToC(native.return_type),
               'NAME': native.name,
               'PARAMS': self.GetParamsInDeclaration(native)}
     return template.substitute(values)
 
@@ skipping 23 matching lines @@
         'OPTIONAL_ERROR_RETURN': optional_error_return,
         'NAME': native.name,
         'PARAMS_IN_DECLARATION': self.GetParamsInDeclaration(native),
         'PARAM0_NAME': native.params[0].name,
         'P0_TYPE': native.p0_type,
         'PARAMS_IN_CALL': params_in_call,
         'POST_CALL': post_call
     }
     return template.substitute(values)
 
+  def GetArgument(self, param):
+    return ("as_jint(" + param.name + ")"

[bulach, 2014/05/06 14:57:55]

nit: s/"/'/

+            if param.datatype == 'int' else param.name)
+
+  def GetArgumentsInCall(self, params):
+    """Return a string of arguments to call from native into Java"""
+    return [self.GetArgument(p) for p in params]
+
   def GetCalledByNativeValues(self, called_by_native):
     """Fills in necessary values for the CalledByNative methods."""
     if called_by_native.static or called_by_native.is_constructor:
       first_param_in_declaration = ''
       first_param_in_call = ('g_%s_clazz' %
                              (called_by_native.java_class_name or
                               self.class_name))
     else:
       first_param_in_declaration = ', jobject obj'
       first_param_in_call = 'obj'
     params_in_declaration = self.GetCalledByNativeParamsInDeclaration(
         called_by_native)
     if params_in_declaration:
       params_in_declaration = ', ' + params_in_declaration
-    params_in_call = ', '.join(param.name for param in called_by_native.params)
+    params_in_call = ', '.join(self.GetArgumentsInCall(called_by_native.params))
     if params_in_call:
       params_in_call = ', ' + params_in_call
     pre_call = ''
     post_call = ''
     if called_by_native.static_cast:
       pre_call = 'static_cast<%s>(' % called_by_native.static_cast
       post_call = ')'
     check_exception = ''
     if not called_by_native.unchecked:
       check_exception = 'jni_generator::CheckException(env);'
@@ skipping 337 matching lines @@
     root_name = os.path.splitext(os.path.basename(input_file))[0]
     output_file = os.path.join(options.output_dir, root_name) + '_jni.h'
   if options.jarjar:
     with open(options.jarjar) as f:
       JniParams.SetJarJarMappings(f.read())
   GenerateJNIHeader(input_file, output_file, options)
 
 
 if __name__ == '__main__':
   sys.exit(main(sys.argv))