Chromoting: Synchronize connected/disconnected state between Java/C++

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/scoped_java_ref.h"
 #include "base/basictypes.h"
 #include "base/command_line.h"
 #include "base/memory/singleton.h"
 #include "base/stl_util.h"
 #include "base/synchronization/waitable_event.h"
 #include "google_apis/google_api_keys.h"
 #include "jni/JniInterface_jni.h"
 #include "media/base/yuv_convert.h"
 #include "remoting/base/url_request_context_getter.h"
 #include "third_party/webrtc/modules/desktop_capture/desktop_frame.h"
 
 using base::android::ConvertJavaStringToUTF8;
 using base::android::ConvertUTF8ToJavaString;
 using base::android::ToJavaByteArray;
 
 namespace {
 
 const int kBytesPerPixel = 4;
 
+remoting::ChromotingJniInstance* GetSession() {

[Sergey Ulanov, 2014/07/24 02:47:02]

nit: Move this inside the remoting namespace below, then you wouldn't need to
specify remoting:: here.

[Lambros, 2014/07/26 00:42:35]

Removed.

+  return remoting::ChromotingJniRuntime::GetInstance()->session();
+}
+
 }  // namespace
 
 namespace remoting {
 
 bool RegisterJni(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++.
@@ skipping 50 matching lines @@
 
 static void Disconnect(JNIEnv* env, jclass clazz) {
   remoting::ChromotingJniRuntime::GetInstance()->DisconnectFromHost();
 }
 
 static void AuthenticationResponse(JNIEnv* env,
                                    jclass clazz,
                                    jstring pin,
                                    jboolean createPair,
                                    jstring deviceName) {
-  remoting::ChromotingJniRuntime::GetInstance()->session()->ProvideSecret(
-      ConvertJavaStringToUTF8(env, pin).c_str(), createPair,
-      ConvertJavaStringToUTF8(env, deviceName));
+  if (GetSession()) {

[Sergey Ulanov, 2014/07/24 02:47:02]

I think it's better to check that the session in Java layer and only then call
this method.

[Lambros, 2014/07/26 00:42:35]

Done.

+    GetSession()->ProvideSecret(
+        ConvertJavaStringToUTF8(env, pin).c_str(), createPair,
+        ConvertJavaStringToUTF8(env, deviceName));
+  }
 }
 
 static void ScheduleRedraw(JNIEnv* env, jclass clazz) {
-  remoting::ChromotingJniRuntime::GetInstance()->session()->RedrawDesktop();
+  if (GetSession()) {
+    GetSession()->RedrawDesktop();
+  }
 }
 
 static void SendMouseEvent(JNIEnv* env,
                            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);
+  if (GetSession()) {
+    GetSession()->SendMouseEvent(
+        x, y,
+        static_cast<remoting::protocol::MouseEvent_MouseButton>(whichButton),
+        buttonDown);
+  }
 }
 
 static void SendMouseWheelEvent(JNIEnv* env,
                                 jclass clazz,
                                 jint delta_x,
                                 jint delta_y) {
-  remoting::ChromotingJniRuntime::GetInstance()->session()->SendMouseWheelEvent(
-      delta_x, delta_y);
+  if (GetSession()) {
+    GetSession()->SendMouseWheelEvent(delta_x, delta_y);
+  }
 }
 
 static jboolean SendKeyEvent(JNIEnv* env,
-                         jclass clazz,
-                         jint keyCode,
-                         jboolean keyDown) {
-  return remoting::ChromotingJniRuntime::GetInstance()->session()->SendKeyEvent(
-      keyCode, keyDown);
+                             jclass clazz,
+                             jint keyCode,
+                             jboolean keyDown) {
+  if (GetSession()) {
+    return GetSession()->SendKeyEvent(keyCode, keyDown);
+  } else {
+    return false;
+  }
 }
 
 static void SendTextEvent(JNIEnv* env,
                           jclass clazz,
                           jstring text) {
-  remoting::ChromotingJniRuntime::GetInstance()->session()->SendTextEvent(
-      ConvertJavaStringToUTF8(env, text));
+  if (GetSession()) {
+    GetSession()->SendTextEvent(ConvertJavaStringToUTF8(env, text));
+  }
 }
 
 static void OnThirdPartyTokenFetched(JNIEnv* env,
                                      jclass clazz,
                                      jstring token,
                                      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)));
+  if (GetSession()) {
+    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)));
+  }
 }
 
 // ChromotingJniRuntime implementation.
 
 // static
 ChromotingJniRuntime* ChromotingJniRuntime::GetInstance() {
   return Singleton<ChromotingJniRuntime>::get();
 }
 
 ChromotingJniRuntime::ChromotingJniRuntime() {
@@ skipping 35 matching lines @@
   done_event.Wait();
   display_task_runner_->PostTask(FROM_HERE, base::Bind(
       &ChromotingJniRuntime::DetachFromVmAndSignal,
       base::Unretained(this),
       &done_event));
   done_event.Wait();
   base::android::DetachFromVM();
 }
 
 void ChromotingJniRuntime::ConnectToHost(const char* username,
-                                  const char* auth_token,
-                                  const char* host_jid,
-                                  const char* host_id,
-                                  const char* host_pubkey,
-                                  const char* pairing_id,
-                                  const char* pairing_secret) {
+                                         const char* auth_token,
+                                         const char* host_jid,
+                                         const char* host_id,
+                                         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,
                                        pairing_id,
                                        pairing_secret);
 }
 
 void ChromotingJniRuntime::DisconnectFromHost() {
   DCHECK(ui_task_runner_->BelongsToCurrentThread());
   if (session_) {
     session_->Disconnect();
     session_ = NULL;
   }
 }
 
 void ChromotingJniRuntime::ReportConnectionStatus(
     protocol::ConnectionToHost::State state,
     protocol::ErrorCode error) {
   DCHECK(ui_task_runner_->BelongsToCurrentThread());
 
+  switch (state) {
+    case protocol::ConnectionToHost::CLOSED:
+    case protocol::ConnectionToHost::FAILED:
+      // If the session has become disconnected, ensure that |session_| gets
+      // cleaned up.
+      DisconnectFromHost();

[Sergey Ulanov, 2014/07/24 02:47:02]

Can the Java layer call Disconnect() when the host is disconnected?

[Lambros, 2014/07/26 00:42:35]

Done.

+      break;
+    default:
+      break;
+  }
   JNIEnv* env = base::android::AttachCurrentThread();
   Java_JniInterface_reportConnectionStatus(env, state, error);
 }
 
 void ChromotingJniRuntime::DisplayAuthenticationPrompt(bool pairing_supported) {
   DCHECK(ui_task_runner_->BelongsToCurrentThread());
 
   JNIEnv* env = base::android::AttachCurrentThread();
   Java_JniInterface_displayAuthenticationPrompt(env, pairing_supported);
 }
@@ skipping 69 matching lines @@
 
   JNIEnv* env = base::android::AttachCurrentThread();
   Java_JniInterface_redrawGraphicsInternal(env);
 }
 
 void ChromotingJniRuntime::DetachFromVmAndSignal(base::WaitableEvent* waiter) {
   base::android::DetachFromVM();
   waiter->Signal();
 }
 }  // namespace remoting