[Android Client] Break down multi-threaded classes by thread

remoting/client/jni/chromoting_jni_instance.cc

Index: remoting/client/jni/chromoting_jni_instance.cc
diff --git a/remoting/client/jni/chromoting_jni_instance.cc b/remoting/client/jni/chromoting_jni_instance.cc
index 0273876ccd0e03581468db8b9865bc19b385b024..b24ce20d869ff5f9c7190c2edf3864df62d36e53 100644
--- a/remoting/client/jni/chromoting_jni_instance.cc
+++ b/remoting/client/jni/chromoting_jni_instance.cc
@@ -7,8 +7,6 @@
 #include <android/log.h>
 #include <stdint.h>
 
-#include <utility>
-
 #include "base/bind.h"
 #include "base/callback_helpers.h"
 #include "base/format_macros.h"
@@ -22,7 +20,9 @@
 #include "remoting/client/jni/android_keymap.h"
 #include "remoting/client/jni/chromoting_jni_runtime.h"
 #include "remoting/client/jni/jni_client.h"
+#include "remoting/client/jni/jni_display_handler.h"
 #include "remoting/client/jni/jni_frame_consumer.h"
+#include "remoting/client/jni/jni_pairing_secret_fetcher.h"
 #include "remoting/client/software_video_renderer.h"
 #include "remoting/protocol/chromium_port_allocator_factory.h"
 #include "remoting/protocol/chromium_socket_factory.h"
@@ -48,19 +48,24 @@ const int kPerfStatsIntervalMs = 60000;
 
 }
 
-ChromotingJniInstance::ChromotingJniInstance(ChromotingJniRuntime* jni_runtime,
-                                             JniClient* jni_client,
-                                             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)
+ChromotingJniInstance::ChromotingJniInstance(
+    ChromotingJniRuntime* jni_runtime,
+    base::WeakPtr<JniClient> jni_client,
+    base::WeakPtr<JniDisplayHandler> display,
+    base::WeakPtr<JniPairingSecretFetcher> secret_fetcher,
+    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)
     : jni_runtime_(jni_runtime),
       jni_client_(jni_client),
+      display_handler_(display),
+      secret_fetcher_(secret_fetcher),
       host_jid_(host_jid),
       flags_(flags),
       capabilities_(capabilities),
@@ -77,22 +82,23 @@ ChromotingJniInstance::ChromotingJniInstance(ChromotingJniRuntime* jni_runtime,
   client_auth_config_.host_id = host_id;
   client_auth_config_.pairing_client_id = pairing_id;
   client_auth_config_.pairing_secret = pairing_secret;
-  client_auth_config_.fetch_secret_callback = base::Bind(
-      &ChromotingJniInstance::FetchSecret, weak_factory_.GetWeakPtr());
-  client_auth_config_.fetch_third_party_token_callback =
-      base::Bind(&ChromotingJniInstance::FetchThirdPartyToken,
-                 weak_factory_.GetWeakPtr(), host_pubkey);
+  client_auth_config_.fetch_secret_callback =
+      base::Bind(&ChromotingJniInstance::FetchSecret, GetWeakPtr());
+  client_auth_config_.fetch_third_party_token_callback = base::Bind(
+      &ChromotingJniInstance::FetchThirdPartyToken, GetWeakPtr(), host_pubkey);
+
+  // Post a task to start connection
+  jni_runtime_->network_task_runner()->PostTask(
+      FROM_HERE,
+      base::Bind(&ChromotingJniInstance::ConnectToHostOnNetworkThread,
+                 GetWeakPtr()));
 }
 
 ChromotingJniInstance::~ChromotingJniInstance() {
-  // This object is ref-counted, so this dtor can execute on any thread.
-  // Ensure that all these objects have been freed already, so they are not
-  // destroyed on some random thread.
-  DCHECK(!view_);
-  DCHECK(!client_context_);
-  DCHECK(!video_renderer_);
-  DCHECK(!client_);
-  DCHECK(!signaling_);
+  DCHECK(jni_runtime_->network_task_runner()->BelongsToCurrentThread());
+  if (client_) {
+    ReleaseResources();
+  }
 }
 
 void ChromotingJniInstance::Connect() {
@@ -101,7 +107,8 @@ void ChromotingJniInstance::Connect() {
   } else {
     jni_runtime_->network_task_runner()->PostTask(
         FROM_HERE,
-        base::Bind(&ChromotingJniInstance::ConnectToHostOnNetworkThread, this));
+        base::Bind(&ChromotingJniInstance::ConnectToHostOnNetworkThread,
+                   GetWeakPtr()));
   }
 }
 
@@ -109,7 +116,7 @@ void ChromotingJniInstance::Disconnect() {
   if (!jni_runtime_->network_task_runner()->BelongsToCurrentThread()) {
     jni_runtime_->network_task_runner()->PostTask(
         FROM_HERE,
-        base::Bind(&ChromotingJniInstance::Disconnect, this));
+        base::Bind(&ChromotingJniInstance::Disconnect, GetWeakPtr()));
     return;
   }
 
@@ -125,15 +132,7 @@ void ChromotingJniInstance::Disconnect() {
     connected_ = false;
   }
 
-  // |client_| must be torn down before |signaling_|.
-  client_.reset();
-  video_renderer_.reset();
-  view_.reset();
-  signaling_.reset();
-  perf_tracker_.reset();
-  client_context_.reset();
-
-  weak_factory_.InvalidateWeakPtrs();
+  ReleaseResources();
 }
 
 void ChromotingJniInstance::FetchThirdPartyToken(
@@ -150,9 +149,8 @@ void ChromotingJniInstance::FetchThirdPartyToken(
 
   third_party_token_fetched_callback_ = token_fetched_callback;
   jni_runtime_->ui_task_runner()->PostTask(
-      FROM_HERE, base::Bind(&JniClient::FetchThirdPartyToken,
-                            jni_client_->GetWeakPtr(), token_url,
-                            host_public_key, scope));
+      FROM_HERE, base::Bind(&JniClient::FetchThirdPartyToken, jni_client_,
+                            token_url, host_public_key, scope));
 }
 
 void ChromotingJniInstance::HandleOnThirdPartyTokenFetched(
@@ -178,26 +176,17 @@ void ChromotingJniInstance::ProvideSecret(const std::string& pin,
                                           bool create_pairing,
                                           const std::string& device_name) {
   DCHECK(jni_runtime_->ui_task_runner()->BelongsToCurrentThread());
-  DCHECK(!pin_callback_.is_null());
+
+  if (!secret_fetcher_) {
+    return;
+  }
 
   create_pairing_ = create_pairing;
 
   if (create_pairing)
     SetDeviceName(device_name);
 
-  jni_runtime_->network_task_runner()->PostTask(FROM_HERE,
-                                                base::Bind(pin_callback_, pin));
-}
-
-void ChromotingJniInstance::RedrawDesktop() {
-  if (!jni_runtime_->display_task_runner()->BelongsToCurrentThread()) {
-    jni_runtime_->display_task_runner()->PostTask(
-        FROM_HERE,
-        base::Bind(&ChromotingJniInstance::RedrawDesktop, this));
-    return;
-  }
-
-  jni_client_->RedrawCanvas();
+  secret_fetcher_->ProvideSecret(pin);
 }
 
 void ChromotingJniInstance::SendMouseEvent(
@@ -207,7 +196,7 @@ void ChromotingJniInstance::SendMouseEvent(
   if (!jni_runtime_->network_task_runner()->BelongsToCurrentThread()) {
     jni_runtime_->network_task_runner()->PostTask(
         FROM_HERE, base::Bind(&ChromotingJniInstance::SendMouseEvent,
-                              this, x, y, button, button_down));
+                              GetWeakPtr(), x, y, button, button_down));
     return;
   }
 
@@ -224,9 +213,8 @@ void ChromotingJniInstance::SendMouseEvent(
 void ChromotingJniInstance::SendMouseWheelEvent(int delta_x, int delta_y) {
   if (!jni_runtime_->network_task_runner()->BelongsToCurrentThread()) {
     jni_runtime_->network_task_runner()->PostTask(
-        FROM_HERE,
-        base::Bind(&ChromotingJniInstance::SendMouseWheelEvent, this,
-                   delta_x, delta_y));
+        FROM_HERE, base::Bind(&ChromotingJniInstance::SendMouseWheelEvent,
+                              GetWeakPtr(), delta_x, delta_y));
     return;
   }
 
@@ -258,7 +246,7 @@ void ChromotingJniInstance::SendTextEvent(const std::string& text) {
   if (!jni_runtime_->network_task_runner()->BelongsToCurrentThread()) {
     jni_runtime_->network_task_runner()->PostTask(
         FROM_HERE,
-        base::Bind(&ChromotingJniInstance::SendTextEvent, this, text));
+        base::Bind(&ChromotingJniInstance::SendTextEvent, GetWeakPtr(), text));
     return;
   }
 
@@ -271,8 +259,8 @@ void ChromotingJniInstance::SendTouchEvent(
     const protocol::TouchEvent& touch_event) {
   if (!jni_runtime_->network_task_runner()->BelongsToCurrentThread()) {
     jni_runtime_->network_task_runner()->PostTask(
-        FROM_HERE,
-        base::Bind(&ChromotingJniInstance::SendTouchEvent, this, touch_event));
+        FROM_HERE, base::Bind(&ChromotingJniInstance::SendTouchEvent,
+                              GetWeakPtr(), touch_event));
     return;
   }
 
@@ -282,8 +270,8 @@ void ChromotingJniInstance::SendTouchEvent(
 void ChromotingJniInstance::EnableVideoChannel(bool enable) {
   if (!jni_runtime_->network_task_runner()->BelongsToCurrentThread()) {
     jni_runtime_->network_task_runner()->PostTask(
-        FROM_HERE,
-        base::Bind(&ChromotingJniInstance::EnableVideoChannel, this, enable));
+        FROM_HERE, base::Bind(&ChromotingJniInstance::EnableVideoChannel,
+                              GetWeakPtr(), enable));
     return;
   }
 
@@ -296,9 +284,8 @@ void ChromotingJniInstance::SendClientMessage(const std::string& type,
                                               const std::string& data) {
   if (!jni_runtime_->network_task_runner()->BelongsToCurrentThread()) {
     jni_runtime_->network_task_runner()->PostTask(
-        FROM_HERE,
-        base::Bind(
-            &ChromotingJniInstance::SendClientMessage, this, type, data));
+        FROM_HERE, base::Bind(&ChromotingJniInstance::SendClientMessage,
+                              GetWeakPtr(), type, data));
     return;
   }
 
@@ -331,10 +318,7 @@ void ChromotingJniInstance::OnConnectionState(
 
   jni_runtime_->ui_task_runner()->PostTask(
       FROM_HERE,
-      base::Bind(&JniClient::OnConnectionState,
-                 jni_client_->GetWeakPtr(),
-                 state,
-                 error));
+      base::Bind(&JniClient::OnConnectionState, jni_client_, state, error));
 }
 
 void ChromotingJniInstance::OnConnectionReady(bool ready) {
@@ -351,25 +335,23 @@ void ChromotingJniInstance::OnRouteChanged(
 
 void ChromotingJniInstance::SetCapabilities(const std::string& capabilities) {
   jni_runtime_->ui_task_runner()->PostTask(
-      FROM_HERE, base::Bind(&JniClient::SetCapabilities,
-                            jni_client_->GetWeakPtr(), capabilities));
+      FROM_HERE,
+      base::Bind(&JniClient::SetCapabilities, jni_client_, capabilities));
 }
 
 void ChromotingJniInstance::SetPairingResponse(
     const protocol::PairingResponse& response) {
   jni_runtime_->ui_task_runner()->PostTask(
-      FROM_HERE,
-      base::Bind(&JniClient::CommitPairingCredentials,
-                 jni_client_->GetWeakPtr(), client_auth_config_.host_id,
-                 response.client_id(), response.shared_secret()));
+      FROM_HERE, base::Bind(&JniClient::CommitPairingCredentials, jni_client_,
+                            client_auth_config_.host_id, response.client_id(),
+                            response.shared_secret()));
 }
 
 void ChromotingJniInstance::DeliverHostMessage(
     const protocol::ExtensionMessage& message) {
   jni_runtime_->ui_task_runner()->PostTask(
-      FROM_HERE, base::Bind(&JniClient::HandleExtensionMessage,
-                            jni_client_->GetWeakPtr(), message.type(),
-                            message.data()));
+      FROM_HERE, base::Bind(&JniClient::HandleExtensionMessage, jni_client_,
+                            message.type(), message.data()));
 }
 
 void ChromotingJniInstance::SetDesktopSize(const webrtc::DesktopSize& size,
@@ -395,12 +377,15 @@ void ChromotingJniInstance::SetCursorShape(
     const protocol::CursorShapeInfo& shape) {
   if (!jni_runtime_->display_task_runner()->BelongsToCurrentThread()) {
     jni_runtime_->display_task_runner()->PostTask(
-        FROM_HERE,
-        base::Bind(&ChromotingJniInstance::SetCursorShape, this, shape));
-    return;
+        FROM_HERE, base::Bind(&JniDisplayHandler::UpdateCursorShape,
+                              display_handler_, shape));
+  } else if (display_handler_) {
+    display_handler_->UpdateCursorShape(shape);
   }
+}
 
-  jni_client_->UpdateCursorShape(shape);
+base::WeakPtr<ChromotingJniInstance> ChromotingJniInstance::GetWeakPtr() {
+  return weak_factory_.GetWeakPtr();
 }
 
 void ChromotingJniInstance::ConnectToHostOnNetworkThread() {
@@ -413,7 +398,7 @@ void ChromotingJniInstance::ConnectToHostOnNetworkThread() {
 
   perf_tracker_.reset(new protocol::PerformanceTracker());
 
-  view_.reset(new JniFrameConsumer(jni_runtime_, jni_client_));
+  view_.reset(new JniFrameConsumer(jni_runtime_, display_handler_));
   video_renderer_.reset(new SoftwareVideoRenderer(
       client_context_->decode_task_runner(), view_.get(), perf_tracker_.get()));
 
@@ -454,23 +439,18 @@ void ChromotingJniInstance::FetchSecret(
     const protocol::SecretFetchedCallback& callback) {
   if (!jni_runtime_->ui_task_runner()->BelongsToCurrentThread()) {
     jni_runtime_->ui_task_runner()->PostTask(
-        FROM_HERE, base::Bind(&ChromotingJniInstance::FetchSecret,
-                              this, pairable, callback));
-    return;
+        FROM_HERE, base::Bind(&JniPairingSecretFetcher::FetchSecret,
+                              secret_fetcher_, pairable, callback));
+  } else if (secret_fetcher_) {
+    secret_fetcher_->FetchSecret(pairable, callback);
   }
-
-  // Delete pairing credentials if they exist.
-  jni_client_->CommitPairingCredentials(client_auth_config_.host_id, "", "");
-
-  pin_callback_ = callback;
-  jni_client_->DisplayAuthenticationPrompt(pairable);
 }
 
 void ChromotingJniInstance::SetDeviceName(const std::string& device_name) {
   if (!jni_runtime_->network_task_runner()->BelongsToCurrentThread()) {
     jni_runtime_->network_task_runner()->PostTask(
-        FROM_HERE, base::Bind(&ChromotingJniInstance::SetDeviceName, this,
-                              device_name));
+        FROM_HERE, base::Bind(&ChromotingJniInstance::SetDeviceName,
+                              GetWeakPtr(), device_name));
     return;
   }
 
@@ -482,7 +462,7 @@ void ChromotingJniInstance::SendKeyEventInternal(int usb_key_code,
   if (!jni_runtime_->network_task_runner()->BelongsToCurrentThread()) {
     jni_runtime_->network_task_runner()->PostTask(
         FROM_HERE, base::Bind(&ChromotingJniInstance::SendKeyEventInternal,
-                              this, usb_key_code, key_down));
+                              GetWeakPtr(), usb_key_code, key_down));
     return;
   }
 
@@ -497,7 +477,8 @@ void ChromotingJniInstance::EnableStatsLogging(bool enabled) {
 
   if (enabled && !stats_logging_enabled_) {
     jni_runtime_->network_task_runner()->PostDelayedTask(
-        FROM_HERE, base::Bind(&ChromotingJniInstance::LogPerfStats, this),
+        FROM_HERE,
+        base::Bind(&ChromotingJniInstance::LogPerfStats, GetWeakPtr()),
         base::TimeDelta::FromMilliseconds(kPerfStatsIntervalMs));
   }
   stats_logging_enabled_ = enabled;
@@ -529,8 +510,20 @@ void ChromotingJniInstance::LogPerfStats() {
   jni_runtime_->logger()->LogStatistics(perf_tracker_.get());
 
   jni_runtime_->network_task_runner()->PostDelayedTask(
-      FROM_HERE, base::Bind(&ChromotingJniInstance::LogPerfStats, this),
+      FROM_HERE, base::Bind(&ChromotingJniInstance::LogPerfStats, GetWeakPtr()),
       base::TimeDelta::FromMilliseconds(kPerfStatsIntervalMs));
 }
 
+void ChromotingJniInstance::ReleaseResources() {
+  // |client_| must be torn down before |signaling_|.
+  client_.reset();
+  video_renderer_.reset();
+  view_.reset();
+  signaling_.reset();
+  perf_tracker_.reset();
+  client_context_.reset();
+
+  weak_factory_.InvalidateWeakPtrs();
+}
+
 }  // namespace remoting