Revert of jni_generator: Make all object-returning natives return ScopedJavaLocalRef.

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 1049 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 = 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 + '>'
+    return_type = JavaDataTypeToC(native.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_DECLARATION} ${NAME}(JNIEnv* env, ${PARAMS});
+static ${RETURN} ${NAME}(JNIEnv* env, ${PARAMS});
 
 ${STUB_VISIBILITY}${RETURN} ${STUB_NAME}(JNIEnv* env, ${PARAMS}) {
-  return ${NAME}(${PARAMS_IN_CALL})${POST_CALL};
+  return ${NAME}(${PARAMS_IN_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 = 'ScopedJavaLocalRef<' + return_type + '>'
+        return_type = 'base::android::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))