Update to Chromium //base at Chromium commit 3e81715e6d3a4324362635aea46ce1f1a163cca1.

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 95 matching lines @@
       'char': 'jchar',
       'short': 'jshort',
       'boolean': 'jboolean',
       'long': 'jlong',
       'double': 'jdouble',
       'float': 'jfloat',
   }
   java_type_map = {
       'void': 'void',
       'String': 'jstring',
+      'Throwable': 'jthrowable',
       'java/lang/String': 'jstring',
       'java/lang/Class': 'jclass',
+      'java/lang/Throwable': 'jthrowable',
   }
 
   if java_type in java_pod_type_map:
     return java_pod_type_map[java_type]
   elif java_type in java_type_map:
     return java_type_map[java_type]
   elif java_type.endswith('[]'):
     if java_type[:-2] in java_pod_type_map:
       return java_pod_type_map[java_type[:-2]] + 'Array'
     return 'jobjectArray'
@@ skipping 295 matching lines @@
         name=match.group('name').replace('native', ''),
         params=JniParams.Parse(match.group('params')),
         ptr_type=ptr_type)
     natives += [native]
   return natives
 
 
 def GetStaticCastForReturnType(return_type):
   type_map = { 'String' : 'jstring',
                'java/lang/String' : 'jstring',
+               'Throwable': 'jthrowable',
+               'java/lang/Throwable': 'jthrowable',
                'boolean[]': 'jbooleanArray',
                'byte[]': 'jbyteArray',
                'char[]': 'jcharArray',
                'short[]': 'jshortArray',
                'int[]': 'jintArray',
                'long[]': 'jlongArray',
                'float[]': 'jfloatArray',
                'double[]': 'jdoubleArray' }
   ret = type_map.get(return_type, None)
   if ret:
@@ skipping 75 matching lines @@
     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|.*Array')
+RE_SCOPED_JNI_RETURN_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 521 matching lines @@
       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])
 
     if self.options.native_exports:
       stub_visibility = 'extern "C" __attribute__((visibility("default")))\n'
     else:
       stub_visibility = 'static '
-    return_type = JavaDataTypeToC(native.return_type)
+    return_type = return_declaration = JavaDataTypeToC(native.return_type)
+    post_call = ''
+    if re.match(RE_SCOPED_JNI_RETURN_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_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
-      post_call = ''
-      if re.match(RE_SCOPED_JNI_RETURN_TYPES, return_type):
-        post_call = '.Release()'
       values.update({
           'OPTIONAL_ERROR_RETURN': optional_error_return,
           'PARAM0_NAME': native.params[0].name,
           'P0_TYPE': native.p0_type,
-          'POST_CALL': post_call,
       })
       template = Template("""\
 ${STUB_VISIBILITY}${RETURN} ${STUB_NAME}(JNIEnv* env,
     ${PARAMS}) {
   ${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} ${NAME}(JNIEnv* env, ${PARAMS});
+static ${RETURN_DECLARATION} ${NAME}(JNIEnv* env, ${PARAMS});
 
 ${STUB_VISIBILITY}${RETURN} ${STUB_NAME}(JNIEnv* env, ${PARAMS}) {
-  return ${NAME}(${PARAMS_IN_CALL});
+  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)
 
   def GetArgumentsInCall(self, params):
@@ skipping 27 matching lines @@
     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):
-        return_type = 'base::android::ScopedJavaLocalRef<' + 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,
         'FIRST_PARAM_IN_DECLARATION': first_param_in_declaration,
@@ skipping 356 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))