Enable Android support for Chromoting PINless (paired) authentication

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/base_jni_registrar.h"
 #include "base/android/jni_android.h"
 #include "base/memory/singleton.h"
 #include "media/base/yuv_convert.h"
@@ skipping 58 matching lines @@
   JNIEnv* env = base::android::AttachCurrentThread();
   env->DeleteGlobalRef(class_);
   // TODO(solb): Detach all threads from JVM here.
   // crbug.com/259594
 }
 
 void ChromotingJniRuntime::ConnectToHost(const char* username,
                                   const char* auth_token,
                                   const char* host_jid,
                                   const char* host_id,
-                                  const char* host_pubkey) {
+                                  const char* host_pubkey,
+                                  const char* pairing_id,
+                                  const char* pairing_secret) {
   DCHECK(ui_task_runner_->BelongsToCurrentThread());
   DCHECK(!session_);
   session_ = new ChromotingJniInstance(this,
                                        username,
                                        auth_token,
                                        host_jid,
                                        host_id,
-                                       host_pubkey);
+                                       host_pubkey,
+                                       pairing_id,
+                                       pairing_secret);
 }
 
 void ChromotingJniRuntime::DisconnectFromHost() {
   DCHECK(ui_task_runner_->BelongsToCurrentThread());
   if (session_) {
     session_->Cleanup();
     session_ = NULL;
   }
 }
 
@@ skipping 12 matching lines @@
 
 void ChromotingJniRuntime::DisplayAuthenticationPrompt() {
   DCHECK(ui_task_runner_->BelongsToCurrentThread());
 
   JNIEnv* env = base::android::AttachCurrentThread();
   env->CallStaticVoidMethod(
       class_,
       env->GetStaticMethodID(class_, "displayAuthenticationPrompt", "()V"));
 }
 
+void ChromotingJniRuntime::CommitPairingCredentials(const std::string& host,
+                                                    const std::string& id,
+                                                    const std::string& secret) {
+  DCHECK(ui_task_runner_->BelongsToCurrentThread());
+
+  JNIEnv* env = base::android::AttachCurrentThread();
+  jstring host_jstr = env->NewStringUTF(host.c_str());
+  jbyteArray id_arr = env->NewByteArray(id.size());
+  env->SetByteArrayRegion(id_arr, 0, id.size(),
+      reinterpret_cast<const jbyte*>(id.c_str()));
+  jbyteArray secret_arr = env->NewByteArray(secret.size());
+  env->SetByteArrayRegion(secret_arr, 0, secret.size(),
+      reinterpret_cast<const jbyte*>(secret.c_str()));
+
+  env->CallStaticVoidMethod(
+      class_,
+      env->GetStaticMethodID(
+          class_,
+          "commitPairingCredentials",
+          "(Ljava/lang/String;[B[B)V"),
+      host_jstr,
+      id_arr,
+      secret_arr);
+
+  // Because we passed them as arguments, their corresponding Java objects were
+  // GCd as soon as the managed method returned, so we mustn't release it here.
+}
+
 void ChromotingJniRuntime::UpdateImageBuffer(int width,
                                              int height,
                                              jobject buffer) {
   DCHECK(display_task_runner_->BelongsToCurrentThread());
 
   JNIEnv* env = base::android::AttachCurrentThread();
   env->SetStaticIntField(
       class_,
       env->GetStaticFieldID(class_, "sWidth", "I"),
       width);
@@ skipping 10 matching lines @@
 void ChromotingJniRuntime::RedrawCanvas() {
   DCHECK(display_task_runner_->BelongsToCurrentThread());
 
   JNIEnv* env = base::android::AttachCurrentThread();
   env->CallStaticVoidMethod(
       class_,
       env->GetStaticMethodID(class_, "redrawGraphicsInternal", "()V"));
 }
 
 }  // namespace remoting