[Remoting Android] Separate the display core from JniGlDisplayHandler

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 30 matching lines @@
 void JniClient::ConnectToHost(const std::string& username,
                               const std::string& auth_token,
                               const std::string& host_jid,
                               const std::string& host_id,
                               const std::string& host_pubkey,
                               const std::string& pairing_id,
                               const std::string& pairing_secret,
                               const std::string& capabilities,
                               const std::string& flags) {
   DCHECK(runtime_->ui_task_runner()->BelongsToCurrentThread());
+  DCHECK(!display_handler_);
   DCHECK(!session_);
   DCHECK(!secret_fetcher_);
+  display_handler_.reset(new JniGlDisplayHandler(runtime_, java_client_));
   secret_fetcher_.reset(new JniPairingSecretFetcher(runtime_, GetWeakPtr(),
                                                     host_id));
   session_.reset(new ChromotingJniInstance(
       runtime_, GetWeakPtr(), secret_fetcher_->GetWeakPtr(),
       display_handler_->CreateCursorShapeStub(),
       display_handler_->CreateVideoRenderer(),
       username, auth_token, host_jid, host_id,
       host_pubkey, pairing_id, pairing_secret, capabilities, flags));
   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 (display_handler_) {
-    display_handler_->Invalidate();
-    runtime_->display_task_runner()->DeleteSoon(FROM_HERE,
-                                                display_handler_.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 64 matching lines @@
     const base::android::JavaParamRef<jobject>& caller,
     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) {
-  display_handler_.reset(new JniGlDisplayHandler(runtime_));
-  display_handler_->Initialize(java_client_);
   ConnectToHost(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_ptr_;
 }
 
 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