jni_generator: Pass object parameters as JavaParamRef.

remoting/client/jni/chromoting_jni_runtime.cc

 // Copyright 2013 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.
 
 #include "remoting/client/jni/chromoting_jni_runtime.h"
 
 #include "base/android/jni_android.h"
 #include "base/android/jni_array.h"
 #include "base/android/jni_string.h"
 #include "base/android/library_loader/library_loader_hooks.h"
@@ skipping 19 matching lines @@
 
 namespace remoting {
 
 bool RegisterChromotingJniRuntime(JNIEnv* env) {
   return remoting::RegisterNativesImpl(env);
 }
 
 // Implementation of stubs defined in JniInterface_jni.h. These are the entry
 // points for JNI calls from Java into C++.
 
-static void LoadNative(JNIEnv* env, jclass clazz, jobject context) {
+static void LoadNative(JNIEnv* env,
+                       const JavaParamRef<jclass>& clazz,
+                       const JavaParamRef<jobject>& context) {
   base::android::ScopedJavaLocalRef<jobject> context_activity(env, context);
   base::android::InitApplicationContext(env, context_activity);
 
   // The google_apis functions check the command-line arguments to make sure no
   // runtime API keys have been specified by the environment. Unfortunately, we
   // neither launch Chromium nor have a command line, so we need to prevent
   // them from DCHECKing out when they go looking.
   base::CommandLine::Init(0, nullptr);
 
   // Create the singleton now so that the Chromoting threads will be set up.
   remoting::ChromotingJniRuntime::GetInstance();
 }
 
-static ScopedJavaLocalRef<jstring> GetApiKey(JNIEnv* env, jclass clazz) {
+static ScopedJavaLocalRef<jstring> GetApiKey(
+    JNIEnv* env,
+    const JavaParamRef<jclass>& clazz) {
   return ConvertUTF8ToJavaString(env, google_apis::GetAPIKey().c_str());
 }
 
-static ScopedJavaLocalRef<jstring> GetClientId(JNIEnv* env, jclass clazz) {
+static ScopedJavaLocalRef<jstring> GetClientId(
+    JNIEnv* env,
+    const JavaParamRef<jclass>& clazz) {
   return ConvertUTF8ToJavaString(
       env,
       google_apis::GetOAuth2ClientID(google_apis::CLIENT_REMOTING).c_str());
 }
 
-static ScopedJavaLocalRef<jstring> GetClientSecret(JNIEnv* env, jclass clazz) {
+static ScopedJavaLocalRef<jstring> GetClientSecret(
+    JNIEnv* env,
+    const JavaParamRef<jclass>& clazz) {
   return ConvertUTF8ToJavaString(
       env,
       google_apis::GetOAuth2ClientSecret(google_apis::CLIENT_REMOTING).c_str());
 }
 
 static void Connect(JNIEnv* env,
-                    jclass clazz,
-                    jstring username,
-                    jstring authToken,
-                    jstring hostJid,
-                    jstring hostId,
-                    jstring hostPubkey,
-                    jstring pairId,
-                    jstring pairSecret,
-                    jstring capabilities) {
+                    const JavaParamRef<jclass>& clazz,
+                    const JavaParamRef<jstring>& username,
+                    const JavaParamRef<jstring>& authToken,
+                    const JavaParamRef<jstring>& hostJid,
+                    const JavaParamRef<jstring>& hostId,
+                    const JavaParamRef<jstring>& hostPubkey,
+                    const JavaParamRef<jstring>& pairId,
+                    const JavaParamRef<jstring>& pairSecret,
+                    const JavaParamRef<jstring>& capabilities) {
   remoting::ChromotingJniRuntime::GetInstance()->ConnectToHost(
       ConvertJavaStringToUTF8(env, username).c_str(),
       ConvertJavaStringToUTF8(env, authToken).c_str(),
       ConvertJavaStringToUTF8(env, hostJid).c_str(),
       ConvertJavaStringToUTF8(env, hostId).c_str(),
       ConvertJavaStringToUTF8(env, hostPubkey).c_str(),
       ConvertJavaStringToUTF8(env, pairId).c_str(),
       ConvertJavaStringToUTF8(env, pairSecret).c_str(),
       ConvertJavaStringToUTF8(env, capabilities).c_str());
 }
 
-static void Disconnect(JNIEnv* env, jclass clazz) {
+static void Disconnect(JNIEnv* env, const JavaParamRef<jclass>& clazz) {
   remoting::ChromotingJniRuntime::GetInstance()->DisconnectFromHost();
 }
 
 static void AuthenticationResponse(JNIEnv* env,
-                                   jclass clazz,
-                                   jstring pin,
+                                   const JavaParamRef<jclass>& clazz,
+                                   const JavaParamRef<jstring>& pin,
                                    jboolean createPair,
-                                   jstring deviceName) {
+                                   const JavaParamRef<jstring>& deviceName) {
   remoting::ChromotingJniRuntime::GetInstance()->session()->ProvideSecret(
       ConvertJavaStringToUTF8(env, pin).c_str(), createPair,
       ConvertJavaStringToUTF8(env, deviceName));
 }
 
-static void ScheduleRedraw(JNIEnv* env, jclass clazz) {
+static void ScheduleRedraw(JNIEnv* env, const JavaParamRef<jclass>& clazz) {
   remoting::ChromotingJniRuntime::GetInstance()->session()->RedrawDesktop();
 }
 
 static void SendMouseEvent(JNIEnv* env,
-                           jclass clazz,
+                           const JavaParamRef<jclass>& clazz,
                            jint x,
                            jint y,
                            jint whichButton,
                            jboolean buttonDown) {
   // Button must be within the bounds of the MouseEvent_MouseButton enum.
   DCHECK(whichButton >= 0 && whichButton < 5);
 
   remoting::ChromotingJniRuntime::GetInstance()->session()->SendMouseEvent(
       x, y,
       static_cast<remoting::protocol::MouseEvent_MouseButton>(whichButton),
       buttonDown);
 }
 
 static void SendMouseWheelEvent(JNIEnv* env,
-                                jclass clazz,
+                                const JavaParamRef<jclass>& clazz,
                                 jint delta_x,
                                 jint delta_y) {
   remoting::ChromotingJniRuntime::GetInstance()->session()->SendMouseWheelEvent(
       delta_x, delta_y);
 }
 
 static jboolean SendKeyEvent(JNIEnv* env,
-                         jclass clazz,
-                         jint keyCode,
-                         jboolean keyDown) {
+                             const JavaParamRef<jclass>& clazz,
+                             jint keyCode,
+                             jboolean keyDown) {
   return remoting::ChromotingJniRuntime::GetInstance()->session()->SendKeyEvent(
       keyCode, keyDown);
 }
 
 static void SendTextEvent(JNIEnv* env,
-                          jclass clazz,
-                          jstring text) {
+                          const JavaParamRef<jclass>& clazz,
+                          const JavaParamRef<jstring>& text) {
   remoting::ChromotingJniRuntime::GetInstance()->session()->SendTextEvent(
       ConvertJavaStringToUTF8(env, text));
 }
 
 static void EnableVideoChannel(JNIEnv* env,
-                               jclass clazz,
+                               const JavaParamRef<jclass>& clazz,
                                jboolean enable) {
   remoting::ChromotingJniRuntime::GetInstance()->session()->EnableVideoChannel(
       enable);
 }
 
-static void OnThirdPartyTokenFetched(JNIEnv* env,
-                                     jclass clazz,
-                                     jstring token,
-                                     jstring shared_secret) {
+static void OnThirdPartyTokenFetched(
+    JNIEnv* env,
+    const JavaParamRef<jclass>& clazz,
+    const JavaParamRef<jstring>& token,
+    const JavaParamRef<jstring>& shared_secret) {
   ChromotingJniRuntime* runtime = remoting::ChromotingJniRuntime::GetInstance();
   runtime->network_task_runner()->PostTask(FROM_HERE, base::Bind(
       &ChromotingJniInstance::HandleOnThirdPartyTokenFetched,
       runtime->session(),
       ConvertJavaStringToUTF8(env, token),
       ConvertJavaStringToUTF8(env, shared_secret)));
 }
 
 static void SendExtensionMessage(JNIEnv* env,
-                                 jclass clazz,
-                                 jstring type,
-                                 jstring data) {
+                                 const JavaParamRef<jclass>& clazz,
+                                 const JavaParamRef<jstring>& type,
+                                 const JavaParamRef<jstring>& data) {
   remoting::ChromotingJniRuntime::GetInstance()->session()->SendClientMessage(
       ConvertJavaStringToUTF8(env, type),
       ConvertJavaStringToUTF8(env, data));
 }
 
 // ChromotingJniRuntime implementation.
 
 // static
 ChromotingJniRuntime* ChromotingJniRuntime::GetInstance() {
   return Singleton<ChromotingJniRuntime>::get();
@@ skipping 178 matching lines @@
 
   JNIEnv* env = base::android::AttachCurrentThread();
   Java_JniInterface_redrawGraphicsInternal(env);
 }
 
 void ChromotingJniRuntime::DetachFromVmAndSignal(base::WaitableEvent* waiter) {
   base::android::DetachFromVM();
   waiter->Signal();
 }
 }  // namespace remoting