[Remoting Android] Make JniClient own JniDisplayHandler

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"
@@ skipping 52 matching lines @@
   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 (display_handler_) {
+    runtime_->display_task_runner()->DeleteSoon(FROM_HERE,
+                                                display_handler_.release());
+  }
 }
 
 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_.obj(), state, error);
 }
 
@@ skipping 57 matching lines @@
 }
 
 // static
 bool JniClient::RegisterJni(JNIEnv* env) {
   return RegisterNativesImpl(env);
 }
 
 void JniClient::Connect(
     JNIEnv* env,
     const base::android::JavaParamRef<jobject>& caller,
-    jlong display_handler,
     const base::android::JavaParamRef<jstring>& username,
     const base::android::JavaParamRef<jstring>& authToken,
     const base::android::JavaParamRef<jstring>& hostJid,
     const base::android::JavaParamRef<jstring>& hostId,
     const base::android::JavaParamRef<jstring>& hostPubkey,
     const base::android::JavaParamRef<jstring>& pairId,
     const base::android::JavaParamRef<jstring>& pairSecret,
     const base::android::JavaParamRef<jstring>& capabilities,
     const base::android::JavaParamRef<jstring>& flags) {
-  // TODO(yuweih): Remove this line when JniClient owns JniDisplayHandler.
-  DisplayUpdaterFactory* factory_ptr = reinterpret_cast<JniDisplayHandler*>(
-              display_handler);
-  DCHECK(factory_ptr);
-  ConnectToHost(factory_ptr,
+#if defined(REMOTING_ANDROID_ENABLE_OPENGL_RENDERER)
+  NOTIMPLEMENTED();

[Lambros, 2016/06/29 00:18:39]

This won't compile - raw_display_handler will be undefined.

Maybe just remove the temporary variable, and call
display_handler_.reset(...) here?

[Yuwei, 2016/06/29 00:40:10]

That's right but I don't think it matters? I would expect
REMOTING_ANDROID_ENABLE_OPENGL_RENDERER to be set after JniGlDisplayHandler is
done...

[Sergey Ulanov, 2016/06/30 18:52:51]

It doesn't matter much, but this code will fail to compile with OpenGL enabled
because raw_display_handler is not defined, so this could be a replaced with
#error.

[Yuwei, 2016/06/30 19:52:02]

Done.

+#else
+  JniDisplayHandler* raw_display_handler = new JniDisplayHandler(runtime_);
+#endif  // defined(REMOTING_ANDROID_ENABLE_OPENGL_RENDERER)
+  Java_Client_setDisplay(env, java_client_.obj(),
+                         raw_display_handler->GetJavaDisplay().obj());
+  display_handler_.reset(raw_display_handler);
+  ConnectToHost(raw_display_handler,
                 ConvertJavaStringToUTF8(env, username),
                 ConvertJavaStringToUTF8(env, authToken),
                 ConvertJavaStringToUTF8(env, hostJid),
                 ConvertJavaStringToUTF8(env, hostId),
                 ConvertJavaStringToUTF8(env, hostPubkey),
                 ConvertJavaStringToUTF8(env, pairId),
                 ConvertJavaStringToUTF8(env, pairSecret),
                 ConvertJavaStringToUTF8(env, capabilities),
                 ConvertJavaStringToUTF8(env, flags));
 }
@@ skipping 114 matching lines @@
   return weak_factory_.GetWeakPtr();
 }
 
 static jlong Init(JNIEnv* env, const JavaParamRef<jobject>& caller) {
   return reinterpret_cast<intptr_t>(
       new JniClient(ChromotingJniRuntime::GetInstance(),
                     base::android::ScopedJavaGlobalRef<jobject>(env, caller)));
 }
 
 }  // namespace remoting