Android: moves jni_generator samples to use long for JNI.

BUG=317523

Review URL: https://codereview.chromium.org/132013003

git-svn-id: svn://svn.chromium.org/chrome/trunk/src@243988 0039d316-1c4b-4281-b951-d872f2087c98

base/android/jni_generator/golden_sample_for_tests_jni.h

@@ -34,7 +34,7 @@ jclass g_InnerStructB_clazz = NULL;
 namespace base {
 namespace android {
 
-static jint Init(JNIEnv* env, jobject jcaller,
+static jlong Init(JNIEnv* env, jobject jcaller,
     jstring param);
 
 static jdouble GetDoubleFunction(JNIEnv* env, jobject jcaller);
@@ -48,21 +48,21 @@ static jobject GetNonPODDatatype(JNIEnv* env, jobject jcaller);
 
 // Step 2: method stubs.
 static void Destroy(JNIEnv* env, jobject jcaller,
-    jint nativeCPPClass) {
+    jlong nativeCPPClass) {
   CPPClass* native = reinterpret_cast<CPPClass*>(nativeCPPClass);
   CHECK_NATIVE_PTR(env, jcaller, native, "Destroy");
   return native->Destroy(env, jcaller);
 }
 
 static jint Method(JNIEnv* env, jobject jcaller,
-    jint nativeCPPClass) {
+    jlong nativeCPPClass) {
   CPPClass* native = reinterpret_cast<CPPClass*>(nativeCPPClass);
   CHECK_NATIVE_PTR(env, jcaller, native, "Method", 0);
   return native->Method(env, jcaller);
 }
 
 static jdouble MethodOtherP0(JNIEnv* env, jobject jcaller,
-    jint nativePtr) {
+    jlong nativePtr) {
   CPPClass::InnerClass* native =
       reinterpret_cast<CPPClass::InnerClass*>(nativePtr);
   CHECK_NATIVE_PTR(env, jcaller, native, "MethodOtherP0", 0);
@@ -70,7 +70,7 @@ static jdouble MethodOtherP0(JNIEnv* env, jobject jcaller,
 }
 
 static void AddStructB(JNIEnv* env, jobject jcaller,
-    jint nativeCPPClass,
+    jlong nativeCPPClass,
     jobject b) {
   CPPClass* native = reinterpret_cast<CPPClass*>(nativeCPPClass);
   CHECK_NATIVE_PTR(env, jcaller, native, "AddStructB");
@@ -78,14 +78,14 @@ static void AddStructB(JNIEnv* env, jobject jcaller,
 }
 
 static void IterateAndDoSomethingWithStructB(JNIEnv* env, jobject jcaller,
-    jint nativeCPPClass) {
+    jlong nativeCPPClass) {
   CPPClass* native = reinterpret_cast<CPPClass*>(nativeCPPClass);
   CHECK_NATIVE_PTR(env, jcaller, native, "IterateAndDoSomethingWithStructB");
   return native->IterateAndDoSomethingWithStructB(env, jcaller);
 }
 
 static jstring ReturnAString(JNIEnv* env, jobject jcaller,
-    jint nativeCPPClass) {
+    jlong nativeCPPClass) {
   CPPClass* native = reinterpret_cast<CPPClass*>(nativeCPPClass);
   CHECK_NATIVE_PTR(env, jcaller, native, "ReturnAString", NULL);
   return native->ReturnAString(env, jcaller).Release();
@@ -315,10 +315,10 @@ static const JNINativeMethod kMethodsSampleForTests[] = {
 "("
 "Ljava/lang/String;"
 ")"
-"I", reinterpret_cast<void*>(Init) },
+"J", reinterpret_cast<void*>(Init) },
     { "nativeDestroy",
 "("
-"I"
+"J"
 ")"
 "V", reinterpret_cast<void*>(Destroy) },
     { "nativeGetDoubleFunction",
@@ -340,28 +340,28 @@ static const JNINativeMethod kMethodsSampleForTests[] = {
 "Ljava/lang/Object;", reinterpret_cast<void*>(GetNonPODDatatype) },
     { "nativeMethod",
 "("
-"I"
+"J"
 ")"
 "I", reinterpret_cast<void*>(Method) },
     { "nativeMethodOtherP0",
 "("
-"I"
+"J"
 ")"
 "D", reinterpret_cast<void*>(MethodOtherP0) },
     { "nativeAddStructB",
 "("
-"I"
+"J"
 "Lorg/chromium/example/jni_generator/SampleForTests$InnerStructB;"
 ")"
 "V", reinterpret_cast<void*>(AddStructB) },
     { "nativeIterateAndDoSomethingWithStructB",
 "("
-"I"
+"J"
 ")"
 "V", reinterpret_cast<void*>(IterateAndDoSomethingWithStructB) },
     { "nativeReturnAString",
 "("
-"I"
+"J"
 ")"
 "Ljava/lang/String;", reinterpret_cast<void*>(ReturnAString) },
 };

base/android/jni_generator/java/src/org/chromium/example/jni_generator/SampleForTests.java

@@ -39,7 +39,7 @@ import java.util.List;
 // functions across boundaries, call only one (and then, internally in the other side,
 // call as many little functions as required).
 //
-// - If a Java object "owns" a native object, stash the pointer in a "int mNativeClassName".
+// - If a Java object "owns" a native object, stash the pointer in a "long mNativeClassName".
 // Note that it needs to have a "destruction path", i.e., it must eventually call a method
 // to delete the native object (for example, the java object has a "close()" method that
 // in turn deletes the native object). Avoid relying on finalizers: those run in a different
@@ -78,7 +78,7 @@ import java.util.List;
 class SampleForTests {
   // Classes can store their C++ pointer counter part as an int that is normally initialized by
   // calling out a nativeInit() function.
-  int mNativeCPPObject;
+  long mNativeCPPObject;
 
   // You can define methods and attributes on the java class just like any other.
   // Methods without the @CalledByNative annotation won't be exposed to JNI.
@@ -168,14 +168,14 @@ class SampleForTests {
   // The caller of this method should store it, and supply it as a the nativeCPPClass param to
   // subsequent native method calls (see the methods below that take an "int native..." as first
   // param).
-  private native int nativeInit(String param);
+  private native long nativeInit(String param);
 
   // This defines a function binding to the associated C++ class member function. The name is
   // derived from |nativeDestroy| and |nativeCPPClass| to arrive at CPPClass::Destroy() (i.e. native
   // prefixes stripped).
   // The |nativeCPPClass| is automatically cast to type CPPClass* in order to obtain the object on
   // which to invoke the member function.
-  private native void nativeDestroy(int nativeCPPClass);
+  private native void nativeDestroy(long nativeCPPClass);
 
   // This declares a C++ function which the application code must implement:
   //   static jdouble GetDoubleFunction(JNIEnv* env, jobject obj);
@@ -200,12 +200,12 @@ class SampleForTests {
 
   // Similar to nativeDestroy above, this will cast nativeCPPClass into pointer of CPPClass type and
   // call its Method member function.
-  private native int nativeMethod(int nativeCPPClass);
+  private native int nativeMethod(long nativeCPPClass);
 
   // Similar to nativeMethod above, but here the C++ fully qualified class name is taken from the
   // annotation rather than parameter name, which can thus be chosen freely.
   @NativeClassQualifiedName("CPPClass::InnerClass")
-  private native double nativeMethodOtherP0(int nativePtr);
+  private native double nativeMethodOtherP0(long nativePtr);
 
   // This "struct" will be created by the native side using |createInnerStructA|,
   // and used by the java-side somehow.
@@ -281,7 +281,7 @@ class SampleForTests {
       nativeIterateAndDoSomethingWithStructB(mNativeCPPObject);
   }
 
-  native void nativeAddStructB(int nativeCPPClass, InnerStructB b);
-  native void nativeIterateAndDoSomethingWithStructB(int nativeCPPClass);
-  native String nativeReturnAString(int nativeCPPClass);
+  native void nativeAddStructB(long nativeCPPClass, InnerStructB b);
+  native void nativeIterateAndDoSomethingWithStructB(long nativeCPPClass);
+  native String nativeReturnAString(long nativeCPPClass);
 }

base/android/jni_generator/jni_generator.gyp

@@ -33,6 +33,7 @@
       ],
       'variables': {
         'jni_gen_package': 'example',
+        'jni_generator_ptr_type': 'long',
       },
       'includes': [ '../../../build/jni_generator.gypi' ],
     },

base/android/jni_generator/jni_generator_tests.py

@@ -37,7 +37,7 @@ class TestOptions(object):
     self.script_name = SCRIPT_NAME
     self.includes = INCLUDES
     self.pure_native_methods = False
-    self.ptr_type = 'int'
+    self.ptr_type = 'long'
     self.jni_init_native_name = None
     self.eager_called_by_natives = False
 
@@ -949,10 +949,10 @@ class Foo {
     package org.chromium.example.jni_generator;
 
     /** The pointer to the native Test. */
-    int nativeTest;
+    long nativeTest;
 
     class Test {
-        private static native int nativeMethod(int nativeTest, int arg1);
+        private static native long nativeMethod(long nativeTest, int arg1);
     }
     """
     options = TestOptions()
@@ -966,11 +966,11 @@ class Foo {
     package org.chromium.example.jni_generator;
 
     /** The pointer to the native Test. */
-    int nativeTest;
+    long nativeTest;
 
     class Test {
         private static native boolean initNativeClass();
-        private static native int nativeMethod(int nativeTest, int arg1);
+        private static native int nativeMethod(long nativeTest, int arg1);
     }
     """
     options = TestOptions()
@@ -984,11 +984,11 @@ class Foo {
     package org.chromium.example.jni_generator;
 
     /** The pointer to the native Test. */
-    int nativeTest;
+    long nativeTest;
 
     class Test {
         private static native boolean initNativeClass();
-        private static native int nativeMethod(int nativeTest, int arg1);
+        private static native int nativeMethod(long nativeTest, int arg1);
         @CalledByNative
         private void testMethodWithParam(int iParam);
         @CalledByNative

base/android/jni_generator/sample_for_tests.cc

@@ -59,7 +59,7 @@ base::android::ScopedJavaLocalRef<jstring> CPPClass::ReturnAString(
 }
 
 // Static free functions declared and called directly from java.
-static jint Init(JNIEnv* env, jobject obj, jstring param) {
+static jlong Init(JNIEnv* env, jobject obj, jstring param) {
   return 0;
 }
 

base/android/jni_generator/testEagerCalledByNativesOption.golden

@@ -27,7 +27,7 @@ jmethodID g_Test_testStaticMethodWithNoParam = NULL;
 
 // Step 2: method stubs.
 static jint Method(JNIEnv* env, jobject jcaller,
-    jint nativeTest,
+    jlong nativeTest,
     jint arg1) {
   Test* native = reinterpret_cast<Test*>(nativeTest);
   CHECK_NATIVE_PTR(env, jcaller, native, "Method", 0);
@@ -67,7 +67,7 @@ static base::android::ScopedJavaLocalRef<jstring>
 static const JNINativeMethod kMethodsTest[] = {
     { "nativeMethod",
 "("
-"I"
+"J"
 "I"
 ")"
 "I", reinterpret_cast<void*>(Method) },

base/android/jni_generator/testJNIInitNativeNameOption.golden

@@ -24,7 +24,7 @@ jclass g_Test_clazz = NULL;
 
 // Step 2: method stubs.
 static jint Method(JNIEnv* env, jobject jcaller,
-    jint nativeTest,
+    jlong nativeTest,
     jint arg1) {
   Test* native = reinterpret_cast<Test*>(nativeTest);
   CHECK_NATIVE_PTR(env, jcaller, native, "Method", 0);
@@ -36,7 +36,7 @@ static jint Method(JNIEnv* env, jobject jcaller,
 static const JNINativeMethod kMethodsTest[] = {
     { "nativeMethod",
 "("
-"I"
+"J"
 "I"
 ")"
 "I", reinterpret_cast<void*>(Method) },

base/android/jni_generator/testPureNativeMethodsOption.golden

@@ -23,8 +23,8 @@ jclass g_Test_clazz = NULL;
 }  // namespace
 
 // Step 2: method stubs.
-static jint Method(JNIEnv* env, jobject jcaller,
-    jint nativeTest,
+static jlong Method(JNIEnv* env, jobject jcaller,
+    jlong nativeTest,
     jint arg1) {
   Test* native = reinterpret_cast<Test*>(nativeTest);
   CHECK_NATIVE_PTR(env, jcaller, native, "Method", 0);
@@ -36,10 +36,10 @@ static jint Method(JNIEnv* env, jobject jcaller,
 static const JNINativeMethod kMethodsTest[] = {
     { "nativeMethod",
 "("
-"I"
+"J"
 "I"
 ")"
-"I", reinterpret_cast<void*>(Method) },
+"J", reinterpret_cast<void*>(Method) },
 };
 
 static bool RegisterNativesImpl(JNIEnv* env) {