Restructure chromoting_jni_instance handling of Java strings

remoting/client/jni/jni_interface.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.
 
 // This file defines functions that implement the static methods declared in a
 // closely-related Java class in the platform-specific user interface
 // implementation.  In effect, it is the entry point for all JNI calls *into*
 // the C++ codebase from Java.  The separate ChromotingJNIInstance class serves
 // as the corresponding exit point, and is responsible for making all JNI calls
 // *out of* the C++ codebase into Java.
@@ skipping 22 matching lines @@
                                                       jobject context) {
   base::android::ScopedJavaLocalRef<jobject> context_activity(env, context);
   base::android::InitApplicationContext(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.
   CommandLine::Init(0, NULL);
 
-  remoting::ChromotingJNIInstance::GetInstance(); // Initialize threads now.
+  // Initialize threads now.

[Wez, 2013/07/12 20:13:41]

nit: Suggest: "Create the JNI singleton to set up Chromoting threads."

[solb, 2013/07/12 21:10:54]

Done.

+  remoting::ChromotingJNIInstance::GetInstance();
 }
 
 JNIEXPORT jstring JNICALL JNI_IMPLEMENTATION(getApiKey)(JNIEnv* env,
                                                         jobject that) {
   return env->NewStringUTF(google_apis::GetAPIKey().c_str());
 }
 
 JNIEXPORT jstring JNICALL JNI_IMPLEMENTATION(getClientId)(JNIEnv* env,
                                                           jobject that) {
   return env->NewStringUTF(
       google_apis::GetOAuth2ClientID(google_apis::CLIENT_REMOTING).c_str());
 }
 
 JNIEXPORT jstring JNICALL JNI_IMPLEMENTATION(getClientSecret)(JNIEnv* env,
                                                               jobject that) {
   return env->NewStringUTF(
       google_apis::GetOAuth2ClientSecret(google_apis::CLIENT_REMOTING).c_str());
 }
 
-JNIEXPORT void JNICALL JNI_IMPLEMENTATION(connectNative)(JNIEnv* env,
-                                                         jobject that,
-                                                         jstring username,
-                                                         jstring auth_token,
-                                                         jstring host_jid,
-                                                         jstring host_id,
-                                                         jstring host_pubkey) {
-  remoting::ChromotingJNIInstance::GetInstance()->ConnectToHost(username,
-                                                                auth_token,
-                                                                host_jid,
-                                                                host_id,
-                                                                host_pubkey);
+JNIEXPORT void JNICALL JNI_IMPLEMENTATION(connectNative)(
+    JNIEnv* env,
+    jobject that,
+    jstring username_jstr,
+    jstring auth_token_jstr,
+    jstring host_jid_jstr,
+    jstring host_id_jstr,
+    jstring host_pubkey_jstr) {
+  const char* username_cstr = env->GetStringUTFChars(username_jstr, NULL);
+  const char* auth_token_cstr = env->GetStringUTFChars(auth_token_jstr, NULL);
+  const char* host_jid_cstr = env->GetStringUTFChars(host_jid_jstr, NULL);
+  const char* host_id_cstr = env->GetStringUTFChars(host_id_jstr, NULL);
+  const char* host_pubkey_cstr = env->GetStringUTFChars(host_pubkey_jstr, NULL);
+
+  remoting::ChromotingJNIInstance::GetInstance()->ConnectToHost(
+      username_cstr,
+      auth_token_cstr,
+      host_jid_cstr,
+      host_id_cstr,
+      host_pubkey_cstr);
+
+  env->ReleaseStringUTFChars(username_jstr, username_cstr);
+  env->ReleaseStringUTFChars(auth_token_jstr, auth_token_cstr);
+  env->ReleaseStringUTFChars(host_jid_jstr, host_jid_cstr);
+  env->ReleaseStringUTFChars(host_id_jstr, host_id_cstr);
+  env->ReleaseStringUTFChars(host_pubkey_jstr, host_pubkey_cstr);
 }
 
 JNIEXPORT void JNICALL JNI_IMPLEMENTATION(disconnectNative)(JNIEnv* env,
                                                             jobject that) {
   remoting::ChromotingJNIInstance::GetInstance()->DisconnectFromHost();
 }
 
-JNIEXPORT void JNICALL JNI_IMPLEMENTATION(authenticationResponse)(JNIEnv* env,
-                                                                  jobject that,
-                                                                  jstring pin) {
-  remoting::ChromotingJNIInstance::GetInstance()->AuthenticateWithPin(pin);
+JNIEXPORT void JNICALL JNI_IMPLEMENTATION(authenticationResponse)(
+    JNIEnv* env,
+    jobject that,
+    jstring pin_jstr) {
+  const char* pin_cstr = env->GetStringUTFChars(pin_jstr, NULL);
+
+  remoting::ChromotingJNIInstance::GetInstance()->AuthenticateWithPin(pin_cstr);
+
+  env->ReleaseStringUTFChars(pin_jstr, pin_cstr);
 }
 
 }  // extern "C"