jni_generator: Pass object parameters as JavaParamRef.

Pass all object parameters to JNI functions in JavaParamRef<> wrappers.
This new type behaves like ScopedJavaLocalRef, but does not free the
local reference when it goes out of scope, since the JVM does not allow
method parameters to be freed and this causes a warning.

This CL only changes the implementation of the generator and the
signatures of JNI functions which take JavaParamRef arguments; the
minimum required to allow it to compile and work. An implicit cast from
JavaParamRef<T> to T is defined, to allow function bodies to remain
unaltered. These will be migrated over future CLs and the cast removed.

BUG=506850

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

Cr-Commit-Position: refs/heads/master@{#347379}

6 files changed, 120 insertions, 90 deletions

diff --git a/mojo/android/javatests/mojo_test_case.cc b/mojo/android/javatests/mojo_test_case.cc
index 3408227..1297a04 100644
--- a/mojo/android/javatests/mojo_test_case.cc
+++ b/mojo/android/javatests/mojo_test_case.cc
@@ -31,24 +31,27 @@ namespace mojo {
 namespace android {
 
 static void InitApplicationContext(JNIEnv* env,
-                                   jobject jcaller,
-                                   jobject context) {
+                                   const JavaParamRef<jobject>& jcaller,
+                                   const JavaParamRef<jobject>& context) {
   base::android::ScopedJavaLocalRef<jobject> scoped_context(env, context);
   base::android::InitApplicationContext(env, scoped_context);
   base::InitAndroidTestMessageLoop();
 }
 
-static jlong SetupTestEnvironment(JNIEnv* env, jobject jcaller) {
+static jlong SetupTestEnvironment(JNIEnv* env,
+                                  const JavaParamRef<jobject>& jcaller) {
   return reinterpret_cast<intptr_t>(new TestEnvironment());
 }
 
 static void TearDownTestEnvironment(JNIEnv* env,
-                                    jobject jcaller,
+                                    const JavaParamRef<jobject>& jcaller,
                                     jlong test_environment) {
   delete reinterpret_cast<TestEnvironment*>(test_environment);
 }
 
-static void RunLoop(JNIEnv* env, jobject jcaller, jlong timeout_ms) {
+static void RunLoop(JNIEnv* env,
+                    const JavaParamRef<jobject>& jcaller,
+                    jlong timeout_ms) {
   base::RunLoop run_loop;
   if (timeout_ms) {
     base::MessageLoop::current()->PostDelayedTask(
diff --git a/mojo/android/javatests/validation_test_util.cc b/mojo/android/javatests/validation_test_util.cc
index dec90cc3..1fb0abf 100644
--- a/mojo/android/javatests/validation_test_util.cc
+++ b/mojo/android/javatests/validation_test_util.cc
@@ -18,9 +18,10 @@ bool RegisterValidationTestUtil(JNIEnv* env) {
   return RegisterNativesImpl(env);
 }
 
-ScopedJavaLocalRef<jobject> ParseData(JNIEnv* env,
-                                      jclass jcaller,
-                                      jstring data_as_string) {
+ScopedJavaLocalRef<jobject> ParseData(
+    JNIEnv* env,
+    const JavaParamRef<jclass>& jcaller,
+    const JavaParamRef<jstring>& data_as_string) {
   std::string input =
       base::android::ConvertJavaStringToUTF8(env, data_as_string);
   std::vector<uint8_t> data;
diff --git a/mojo/android/system/base_run_loop.cc b/mojo/android/system/base_run_loop.cc
index 2bc2fb4..df78561b 100644
--- a/mojo/android/system/base_run_loop.cc
+++ b/mojo/android/system/base_run_loop.cc
@@ -17,21 +17,28 @@
 namespace mojo {
 namespace android {
 
-static jlong CreateBaseRunLoop(JNIEnv* env, jobject jcaller) {
+static jlong CreateBaseRunLoop(JNIEnv* env,
+                               const JavaParamRef<jobject>& jcaller) {
   base::MessageLoop* message_loop =
       new base::MessageLoop(common::MessagePumpMojo::Create());
   return reinterpret_cast<uintptr_t>(message_loop);
 }
 
-static void Run(JNIEnv* env, jobject jcaller, jlong runLoopID) {
+static void Run(JNIEnv* env,
+                const JavaParamRef<jobject>& jcaller,
+                jlong runLoopID) {
   reinterpret_cast<base::MessageLoop*>(runLoopID)->Run();
 }
 
-static void RunUntilIdle(JNIEnv* env, jobject jcaller, jlong runLoopID) {
+static void RunUntilIdle(JNIEnv* env,
+                         const JavaParamRef<jobject>& jcaller,
+                         jlong runLoopID) {
   reinterpret_cast<base::MessageLoop*>(runLoopID)->RunUntilIdle();
 }
 
-static void Quit(JNIEnv* env, jobject jcaller, jlong runLoopID) {
+static void Quit(JNIEnv* env,
+                 const JavaParamRef<jobject>& jcaller,
+                 jlong runLoopID) {
   reinterpret_cast<base::MessageLoop*>(runLoopID)->Quit();
 }
 
@@ -42,9 +49,9 @@ static void RunJavaRunnable(
 }
 
 static void PostDelayedTask(JNIEnv* env,
-                            jobject jcaller,
+                            const JavaParamRef<jobject>& jcaller,
                             jlong runLoopID,
-                            jobject runnable,
+                            const JavaParamRef<jobject>& runnable,
                             jlong delay) {
   base::android::ScopedJavaGlobalRef<jobject> runnable_ref;
   // ScopedJavaGlobalRef do not hold onto the env reference, so it is safe to
@@ -56,7 +63,9 @@ static void PostDelayedTask(JNIEnv* env,
       base::TimeDelta::FromMicroseconds(delay));
 }
 
-static void DeleteMessageLoop(JNIEnv* env, jobject jcaller, jlong runLoopID) {
+static void DeleteMessageLoop(JNIEnv* env,
+                              const JavaParamRef<jobject>& jcaller,
+                              jlong runLoopID) {
   base::MessageLoop* message_loop =
       reinterpret_cast<base::MessageLoop*>(runLoopID);
   delete message_loop;
diff --git a/mojo/android/system/core_impl.cc b/mojo/android/system/core_impl.cc
index 6319116..2158987 100644
--- a/mojo/android/system/core_impl.cc
+++ b/mojo/android/system/core_impl.cc
@@ -49,13 +49,14 @@ void AsyncWaitCallback(void* data, MojoResult result) {
 namespace mojo {
 namespace android {
 
-static jlong GetTimeTicksNow(JNIEnv* env, jobject jcaller) {
+static jlong GetTimeTicksNow(JNIEnv* env,
+                             const JavaParamRef<jobject>& jcaller) {
   return MojoGetTimeTicksNow();
 }
 
 static jint WaitMany(JNIEnv* env,
-                     jobject jcaller,
-                     jobject buffer,
+                     const JavaParamRef<jobject>& jcaller,
+                     const JavaParamRef<jobject>& buffer,
                      jlong deadline) {
   // |buffer| contains, in this order
   // input: The array of N handles (MojoHandle, 4 bytes each)
@@ -88,9 +89,10 @@ static jint WaitMany(JNIEnv* env,
                       result_index, states_start);
 }
 
-static ScopedJavaLocalRef<jobject> CreateMessagePipe(JNIEnv* env,
-                                                     jobject jcaller,
-                                                     jobject options_buffer) {
+static ScopedJavaLocalRef<jobject> CreateMessagePipe(
+    JNIEnv* env,
+    const JavaParamRef<jobject>& jcaller,
+    const JavaParamRef<jobject>& options_buffer) {
   const MojoCreateMessagePipeOptions* options = NULL;
   if (options_buffer) {
     const void* buffer_start = env->GetDirectBufferAddress(options_buffer);
@@ -107,9 +109,10 @@ static ScopedJavaLocalRef<jobject> CreateMessagePipe(JNIEnv* env,
   return Java_CoreImpl_newNativeCreationResult(env, result, handle1, handle2);
 }
 
-static ScopedJavaLocalRef<jobject> CreateDataPipe(JNIEnv* env,
-                                                  jobject jcaller,
-                                                  jobject options_buffer) {
+static ScopedJavaLocalRef<jobject> CreateDataPipe(
+    JNIEnv* env,
+    const JavaParamRef<jobject>& jcaller,
+    const JavaParamRef<jobject>& options_buffer) {
   const MojoCreateDataPipeOptions* options = NULL;
   if (options_buffer) {
     const void* buffer_start = env->GetDirectBufferAddress(options_buffer);
@@ -126,10 +129,11 @@ static ScopedJavaLocalRef<jobject> CreateDataPipe(JNIEnv* env,
   return Java_CoreImpl_newNativeCreationResult(env, result, handle1, handle2);
 }
 
-static ScopedJavaLocalRef<jobject> CreateSharedBuffer(JNIEnv* env,
-                                                      jobject jcaller,
-                                                      jobject options_buffer,
-                                                      jlong num_bytes) {
+static ScopedJavaLocalRef<jobject> CreateSharedBuffer(
+    JNIEnv* env,
+    const JavaParamRef<jobject>& jcaller,
+    const JavaParamRef<jobject>& options_buffer,
+    jlong num_bytes) {
   const MojoCreateSharedBufferOptions* options = 0;
   if (options_buffer) {
     const void* buffer_start = env->GetDirectBufferAddress(options_buffer);
@@ -145,13 +149,15 @@ static ScopedJavaLocalRef<jobject> CreateSharedBuffer(JNIEnv* env,
   return Java_CoreImpl_newResultAndInteger(env, result, handle);
 }
 
-static jint Close(JNIEnv* env, jobject jcaller, jint mojo_handle) {
+static jint Close(JNIEnv* env,
+                  const JavaParamRef<jobject>& jcaller,
+                  jint mojo_handle) {
   return MojoClose(mojo_handle);
 }
 
 static jint Wait(JNIEnv* env,
-                 jobject jcaller,
-                 jobject buffer,
+                 const JavaParamRef<jobject>& jcaller,
+                 const JavaParamRef<jobject>& buffer,
                  jint mojo_handle,
                  jint signals,
                  jlong deadline) {
@@ -167,11 +173,11 @@ static jint Wait(JNIEnv* env,
 }
 
 static jint WriteMessage(JNIEnv* env,
-                         jobject jcaller,
+                         const JavaParamRef<jobject>& jcaller,
                          jint mojo_handle,
-                         jobject bytes,
+                         const JavaParamRef<jobject>& bytes,
                          jint num_bytes,
-                         jobject handles_buffer,
+                         const JavaParamRef<jobject>& handles_buffer,
                          jint flags) {
   const void* buffer_start = 0;
   uint32_t buffer_size = 0;
@@ -193,12 +199,13 @@ static jint WriteMessage(JNIEnv* env,
       mojo_handle, buffer_start, buffer_size, handles, num_handles, flags);
 }
 
-static ScopedJavaLocalRef<jobject> ReadMessage(JNIEnv* env,
-                                               jobject jcaller,
-                                               jint mojo_handle,
-                                               jobject bytes,
-                                               jobject handles_buffer,
-                                               jint flags) {
+static ScopedJavaLocalRef<jobject> ReadMessage(
+    JNIEnv* env,
+    const JavaParamRef<jobject>& jcaller,
+    jint mojo_handle,
+    const JavaParamRef<jobject>& bytes,
+    const JavaParamRef<jobject>& handles_buffer,
+    jint flags) {
   void* buffer_start = 0;
   uint32_t buffer_size = 0;
   if (bytes) {
@@ -220,12 +227,13 @@ static ScopedJavaLocalRef<jobject> ReadMessage(JNIEnv* env,
                                             num_handles);
 }
 
-static ScopedJavaLocalRef<jobject> ReadData(JNIEnv* env,
-                                            jobject jcaller,
-                                            jint mojo_handle,
-                                            jobject elements,
-                                            jint elements_capacity,
-                                            jint flags) {
+static ScopedJavaLocalRef<jobject> ReadData(
+    JNIEnv* env,
+    const JavaParamRef<jobject>& jcaller,
+    jint mojo_handle,
+    const JavaParamRef<jobject>& elements,
+    jint elements_capacity,
+    jint flags) {
   void* buffer_start = 0;
   uint32_t buffer_size = elements_capacity;
   if (elements) {
@@ -239,11 +247,12 @@ static ScopedJavaLocalRef<jobject> ReadData(JNIEnv* env,
       env, result, (result == MOJO_RESULT_OK) ? buffer_size : 0);
 }
 
-static ScopedJavaLocalRef<jobject> BeginReadData(JNIEnv* env,
-                                                 jobject jcaller,
-                                                 jint mojo_handle,
-                                                 jint num_bytes,
-                                                 jint flags) {
+static ScopedJavaLocalRef<jobject> BeginReadData(
+    JNIEnv* env,
+    const JavaParamRef<jobject>& jcaller,
+    jint mojo_handle,
+    jint num_bytes,
+    jint flags) {
   void const* buffer = 0;
   uint32_t buffer_size = num_bytes;
   MojoResult result =
@@ -257,18 +266,19 @@ static ScopedJavaLocalRef<jobject> BeginReadData(JNIEnv* env,
 }
 
 static jint EndReadData(JNIEnv* env,
-                        jobject jcaller,
+                        const JavaParamRef<jobject>& jcaller,
                         jint mojo_handle,
                         jint num_bytes_read) {
   return MojoEndReadData(mojo_handle, num_bytes_read);
 }
 
-static ScopedJavaLocalRef<jobject> WriteData(JNIEnv* env,
-                                             jobject jcaller,
-                                             jint mojo_handle,
-                                             jobject elements,
-                                             jint limit,
-                                             jint flags) {
+static ScopedJavaLocalRef<jobject> WriteData(
+    JNIEnv* env,
+    const JavaParamRef<jobject>& jcaller,
+    jint mojo_handle,
+    const JavaParamRef<jobject>& elements,
+    jint limit,
+    jint flags) {
   void* buffer_start = env->GetDirectBufferAddress(elements);
   DCHECK(buffer_start);
   DCHECK(limit <= env->GetDirectBufferCapacity(elements));
@@ -279,11 +289,12 @@ static ScopedJavaLocalRef<jobject> WriteData(JNIEnv* env,
       env, result, (result == MOJO_RESULT_OK) ? buffer_size : 0);
 }
 
-static ScopedJavaLocalRef<jobject> BeginWriteData(JNIEnv* env,
-                                                  jobject jcaller,
-                                                  jint mojo_handle,
-                                                  jint num_bytes,
-                                                  jint flags) {
+static ScopedJavaLocalRef<jobject> BeginWriteData(
+    JNIEnv* env,
+    const JavaParamRef<jobject>& jcaller,
+    jint mojo_handle,
+    jint num_bytes,
+    jint flags) {
   void* buffer = 0;
   uint32_t buffer_size = num_bytes;
   MojoResult result =
@@ -296,16 +307,17 @@ static ScopedJavaLocalRef<jobject> BeginWriteData(JNIEnv* env,
 }
 
 static jint EndWriteData(JNIEnv* env,
-                         jobject jcaller,
+                         const JavaParamRef<jobject>& jcaller,
                          jint mojo_handle,
                          jint num_bytes_written) {
   return MojoEndWriteData(mojo_handle, num_bytes_written);
 }
 
-static ScopedJavaLocalRef<jobject> Duplicate(JNIEnv* env,
-                                             jobject jcaller,
-                                             jint mojo_handle,
-                                             jobject options_buffer) {
+static ScopedJavaLocalRef<jobject> Duplicate(
+    JNIEnv* env,
+    const JavaParamRef<jobject>& jcaller,
+    jint mojo_handle,
+    const JavaParamRef<jobject>& options_buffer) {
   const MojoDuplicateBufferHandleOptions* options = 0;
   if (options_buffer) {
     const void* buffer_start = env->GetDirectBufferAddress(options_buffer);
@@ -322,7 +334,7 @@ static ScopedJavaLocalRef<jobject> Duplicate(JNIEnv* env,
 }
 
 static ScopedJavaLocalRef<jobject> Map(JNIEnv* env,
-                                       jobject jcaller,
+                                       const JavaParamRef<jobject>& jcaller,
                                        jint mojo_handle,
                                        jlong offset,
                                        jlong num_bytes,
@@ -337,18 +349,21 @@ static ScopedJavaLocalRef<jobject> Map(JNIEnv* env,
   return Java_CoreImpl_newResultAndBuffer(env, result, byte_buffer);
 }
 
-static int Unmap(JNIEnv* env, jobject jcaller, jobject buffer) {
+static int Unmap(JNIEnv* env,
+                 const JavaParamRef<jobject>& jcaller,
+                 const JavaParamRef<jobject>& buffer) {
   void* buffer_start = env->GetDirectBufferAddress(buffer);
   DCHECK(buffer_start);
   return MojoUnmapBuffer(buffer_start);
 }
 
-static ScopedJavaLocalRef<jobject> AsyncWait(JNIEnv* env,
-                                             jobject jcaller,
-                                             jint mojo_handle,
-                                             jint signals,
-                                             jlong deadline,
-                                             jobject callback) {
+static ScopedJavaLocalRef<jobject> AsyncWait(
+    JNIEnv* env,
+    const JavaParamRef<jobject>& jcaller,
+    jint mojo_handle,
+    jint signals,
+    jlong deadline,
+    const JavaParamRef<jobject>& callback) {
   AsyncWaitCallbackData* callback_data =
       new AsyncWaitCallbackData(env, jcaller, callback);
   MojoAsyncWaitID cancel_id;
@@ -370,7 +385,7 @@ static ScopedJavaLocalRef<jobject> AsyncWait(JNIEnv* env,
 }
 
 static void CancelAsyncWait(JNIEnv* env,
-                            jobject jcaller,
+                            const JavaParamRef<jobject>& jcaller,
                             jlong id,
                             jlong data_ptr) {
   if (id == 0) {
@@ -385,8 +400,8 @@ static void CancelAsyncWait(JNIEnv* env,
 }
 
 static jint GetNativeBufferOffset(JNIEnv* env,
-                                  jobject jcaller,
-                                  jobject buffer,
+                                  const JavaParamRef<jobject>& jcaller,
+                                  const JavaParamRef<jobject>& buffer,
                                   jint alignment) {
   jint offset =
       reinterpret_cast<uintptr_t>(env->GetDirectBufferAddress(buffer)) %
diff --git a/mojo/runner/android/bootstrap.cc b/mojo/runner/android/bootstrap.cc
index adcf81f..39890c8 100644
--- a/mojo/runner/android/bootstrap.cc
+++ b/mojo/runner/android/bootstrap.cc
@@ -13,9 +13,9 @@ namespace mojo {
 namespace runner {
 
 void Bootstrap(JNIEnv* env,
-               jobject,
-               jobject j_context,
-               jstring j_native_library_path,
+               const JavaParamRef<jobject>&,
+               const JavaParamRef<jobject>& j_context,
+               const JavaParamRef<jstring>& j_native_library_path,
                jint j_handle,
                jlong j_run_application_ptr,
                jboolean is_cached_app) {
diff --git a/mojo/runner/android/main.cc b/mojo/runner/android/main.cc
index 8f4db82..b5717cc 100644
--- a/mojo/runner/android/main.cc
+++ b/mojo/runner/android/main.cc
@@ -99,12 +99,12 @@ void InitializeRedirection() {
 }  // namespace
 
 static void Init(JNIEnv* env,
-                 jclass clazz,
-                 jobject activity,
-                 jstring mojo_shell_path,
-                 jobjectArray jparameters,
-                 jstring j_local_apps_directory,
-                 jstring j_tmp_dir) {
+                 const JavaParamRef<jclass>& clazz,
+                 const JavaParamRef<jobject>& activity,
+                 const JavaParamRef<jstring>& mojo_shell_path,
+                 const JavaParamRef<jobjectArray>& jparameters,
+                 const JavaParamRef<jstring>& j_local_apps_directory,
+                 const JavaParamRef<jstring>& j_tmp_dir) {
   g_main_activiy.Get().Reset(env, activity);
 
   // Setting the TMPDIR environment variable so that applications can use it.
@@ -155,7 +155,7 @@ static void Init(JNIEnv* env,
   gfx::GLSurface::InitializeOneOff();
 }
 
-static void Start(JNIEnv* env, jclass clazz) {
+static void Start(JNIEnv* env, const JavaParamRef<jclass>& clazz) {
 #if defined(MOJO_SHELL_DEBUG_URL)
   base::CommandLine::ForCurrentProcess()->AppendArg(MOJO_SHELL_DEBUG_URL);
   // Sleep for 5 seconds to give the debugger a chance to attach.
@@ -166,7 +166,9 @@ static void Start(JNIEnv* env, jclass clazz) {
   context->RunCommandLineApplication(base::Bind(ExitShell));
 }
 
-static void AddApplicationURL(JNIEnv* env, jclass clazz, jstring jurl) {
+static void AddApplicationURL(JNIEnv* env,
+                              const JavaParamRef<jclass>& clazz,
+                              const JavaParamRef<jstring>& jurl) {
   base::CommandLine::ForCurrentProcess()->AppendArg(
       base::android::ConvertJavaStringToUTF8(env, jurl));
 }