Refactoring and rewriting the chromoting jni instance to be chromoting session.

remoting/client/jni/jni_client.cc

 // Copyright 2016 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/jni_client.h"
 
 #include "base/android/jni_android.h"
 #include "base/android/jni_string.h"
 #include "base/logging.h"
 #include "jni/Client_jni.h"
+#include "remoting/client/audio_player_android.h"
 #include "remoting/client/chromoting_client_runtime.h"
-#include "remoting/client/jni/chromoting_jni_instance.h"
-#include "remoting/client/jni/connect_to_host_info.h"
+#include "remoting/client/chromoting_session.h"
+#include "remoting/client/connect_to_host_info.h"
 #include "remoting/client/jni/jni_gl_display_handler.h"
 #include "remoting/client/jni/jni_pairing_secret_fetcher.h"
+#include "remoting/client/jni/jni_runtime_delegate.h"
 #include "remoting/client/jni/jni_touch_event_data.h"
 #include "remoting/protocol/video_renderer.h"
 
 using base::android::ConvertJavaStringToUTF8;
 using base::android::ConvertUTF8ToJavaString;
 using base::android::JavaParamRef;
 using base::android::ScopedJavaLocalRef;
 
 namespace remoting {
 
 JniClient::JniClient(base::android::ScopedJavaGlobalRef<jobject> java_client)
     : java_client_(java_client), weak_factory_(this) {
   runtime_ = ChromotingClientRuntime::GetInstance();
   weak_ptr_ = weak_factory_.GetWeakPtr();
 }
 
 JniClient::~JniClient() {
   DCHECK(runtime_->ui_task_runner()->BelongsToCurrentThread());
 
   // The session must be shut down first, since it depends on our other
   // components' still being alive.
   DisconnectFromHost();
 }
 
 void JniClient::ConnectToHost(const ConnectToHostInfo& info) {
   DCHECK(runtime_->ui_task_runner()->BelongsToCurrentThread());
   DCHECK(!display_handler_);
+  DCHECK(!audio_player_);
   DCHECK(!session_);
   DCHECK(!secret_fetcher_);
   display_handler_.reset(new JniGlDisplayHandler(java_client_));
   secret_fetcher_.reset(
       new JniPairingSecretFetcher(GetWeakPtr(), info.host_id));
-  session_.reset(
-      new ChromotingJniInstance(GetWeakPtr(), secret_fetcher_->GetWeakPtr(),
-                                display_handler_->CreateCursorShapeStub(),
-                                display_handler_->CreateVideoRenderer(), info));
+
+  protocol::ClientAuthenticationConfig client_auth_config;
+  client_auth_config.host_id = info.host_id;
+  client_auth_config.pairing_client_id = info.pairing_id;
+  client_auth_config.pairing_secret = info.pairing_secret;
+  client_auth_config.fetch_secret_callback = base::Bind(
+      &JniPairingSecretFetcher::FetchSecret, secret_fetcher_->GetWeakPtr());
+
+  audio_player_.reset(new AudioPlayerAndroid());
+
+  session_.reset(new ChromotingSession(
+      weak_ptr_, display_handler_->CreateCursorShapeStub(),
+      display_handler_->CreateVideoRenderer(), audio_player_->GetWeakPtr(),
+      info, client_auth_config));
   session_->Connect();
 }
 
 void JniClient::DisconnectFromHost() {
   DCHECK(runtime_->ui_task_runner()->BelongsToCurrentThread());
   if (session_) {
     session_->Disconnect();
     runtime_->network_task_runner()->DeleteSoon(FROM_HERE,
                                                 session_.release());
   }
   if (secret_fetcher_) {
     runtime_->network_task_runner()->DeleteSoon(FROM_HERE,
                                                 secret_fetcher_.release());
   }
+  if (audio_player_) {
+    runtime_->network_task_runner()->DeleteSoon(FROM_HERE,
+                                                audio_player_.release());
+  }
   display_handler_.reset();
 }
 
 void JniClient::OnConnectionState(protocol::ConnectionToHost::State state,
                                   protocol::ErrorCode error) {
   DCHECK(runtime_->ui_task_runner()->BelongsToCurrentThread());
 
   JNIEnv* env = base::android::AttachCurrentThread();
   Java_Client_onConnectionState(env, java_client_, state, error);
 }
@@ skipping 81 matching lines @@
   info.host_jid = ConvertJavaStringToUTF8(env, host_jid);
   info.host_id = ConvertJavaStringToUTF8(env, host_id);
   info.host_pubkey = ConvertJavaStringToUTF8(env, host_pubkey);
   info.pairing_id = ConvertJavaStringToUTF8(env, pair_id);
   info.pairing_secret = ConvertJavaStringToUTF8(env, pair_secret);
   info.capabilities = ConvertJavaStringToUTF8(env, capabilities);
   info.flags = ConvertJavaStringToUTF8(env, flags);
   info.host_version = ConvertJavaStringToUTF8(env, host_version);
   info.host_os = ConvertJavaStringToUTF8(env, host_os);
   info.host_os_version = ConvertJavaStringToUTF8(env, host_os_version);
+
   ConnectToHost(info);
 }
 
 void JniClient::Disconnect(JNIEnv* env,
                            const base::android::JavaParamRef<jobject>& caller) {
   DisconnectFromHost();
 }
 
 void JniClient::AuthenticationResponse(
     JNIEnv* env,
     const JavaParamRef<jobject>& caller,
     const JavaParamRef<jstring>& pin,
     jboolean createPair,
     const JavaParamRef<jstring>& deviceName) {
-  session_->ProvideSecret(ConvertJavaStringToUTF8(env, pin), createPair,
-                          ConvertJavaStringToUTF8(env, deviceName));
+  if (session_) {
+    session_->ProvideSecret(ConvertJavaStringToUTF8(env, pin), createPair,
+                            ConvertJavaStringToUTF8(env, deviceName));
+  }
+
+  if (secret_fetcher_) {
+    runtime_->network_task_runner()->PostTask(
+        FROM_HERE, base::Bind(&JniPairingSecretFetcher::ProvideSecret,
+                              secret_fetcher_->GetWeakPtr(),
+                              ConvertJavaStringToUTF8(env, pin)));
+  }
 }
 
 void JniClient::SendMouseEvent(
     JNIEnv* env,
     const base::android::JavaParamRef<jobject>& caller,
     jint x,
     jint y,
     jint whichButton,
     jboolean buttonDown) {
   // Button must be within the bounds of the MouseEvent_MouseButton enum.
@@ skipping 61 matching lines @@
   session_->EnableVideoChannel(enable);
 }
 
 void JniClient::OnThirdPartyTokenFetched(
     JNIEnv* env,
     const base::android::JavaParamRef<jobject>& caller,
     const JavaParamRef<jstring>& token,
     const JavaParamRef<jstring>& shared_secret) {
   runtime_->network_task_runner()->PostTask(
       FROM_HERE,
-      base::Bind(&ChromotingJniInstance::HandleOnThirdPartyTokenFetched,
+      base::Bind(&ChromotingSession::HandleOnThirdPartyTokenFetched,
                  session_->GetWeakPtr(), ConvertJavaStringToUTF8(env, token),
                  ConvertJavaStringToUTF8(env, shared_secret)));
 }
 
 void JniClient::SendExtensionMessage(
     JNIEnv* env,
     const base::android::JavaParamRef<jobject>& caller,
     const JavaParamRef<jstring>& type,
     const JavaParamRef<jstring>& data) {
   session_->SendClientMessage(ConvertJavaStringToUTF8(env, type),
                               ConvertJavaStringToUTF8(env, data));
 }
 
 void JniClient::Destroy(JNIEnv* env, const JavaParamRef<jobject>& caller) {
   delete this;
 }
 
 base::WeakPtr<JniClient> JniClient::GetWeakPtr() {
   return weak_ptr_;
 }
 
 static jlong Init(JNIEnv* env, const JavaParamRef<jobject>& caller) {
   return reinterpret_cast<intptr_t>(
       new JniClient(base::android::ScopedJavaGlobalRef<jobject>(env, caller)));
 }
 
 }  // namespace remoting