[Remoting Android] Move pairing secret fetcher to the network thread

remoting/client/jni/chromoting_jni_instance.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_instance.h"
 
 #include <android/log.h>
 #include <stdint.h>
 
 #include "base/bind.h"
@@ skipping 65 matching lines @@
   xmpp_config_.host = kXmppServer;
   xmpp_config_.port = kXmppPort;
   xmpp_config_.use_tls = kXmppUseTls;
   xmpp_config_.username = username;
   xmpp_config_.auth_token = auth_token;
 
   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, GetWeakPtr());
+      base::Bind(&JniPairingSecretFetcher::FetchSecret, secret_fetcher);
   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()));
 }
 
@@ skipping 73 matching lines @@
         "ThirdPartyAuth",
         "Ignored OnThirdPartyTokenFetched() without a pending fetch.");
   }
 }
 
 void ChromotingJniInstance::ProvideSecret(const std::string& pin,
                                           bool create_pairing,
                                           const std::string& device_name) {
   DCHECK(jni_runtime_->ui_task_runner()->BelongsToCurrentThread());
 
-  if (!secret_fetcher_) {
-    return;
-  }
-
   create_pairing_ = create_pairing;
 
   if (create_pairing)
     SetDeviceName(device_name);
 
-  secret_fetcher_->ProvideSecret(pin);
+  jni_runtime_->network_task_runner()->PostTask(
+      FROM_HERE, base::Bind(&JniPairingSecretFetcher::ProvideSecret,
+                            secret_fetcher_, pin));
 }
 
 void ChromotingJniInstance::SendMouseEvent(
     int x, int y,
     protocol::MouseEvent_MouseButton button,
     bool button_down) {
   if (!jni_runtime_->network_task_runner()->BelongsToCurrentThread()) {
     jni_runtime_->network_task_runner()->PostTask(
         FROM_HERE, base::Bind(&ChromotingJniInstance::SendMouseEvent,
                               GetWeakPtr(), x, y, button, button_down));
@@ skipping 227 matching lines @@
         protocol::CandidateSessionConfig::CreateEmpty();
     protocol_config->set_webrtc_supported(true);
     protocol_config->set_ice_supported(false);
     client_->set_protocol_config(std::move(protocol_config));
   }
 #endif  // defined(ENABLE_WEBRTC_REMOTING_CLIENT)
   client_->Start(signaling_.get(), client_auth_config_, transport_context,
                  host_jid_, capabilities_);
 }
 
-void ChromotingJniInstance::FetchSecret(
-    bool pairable,
-    const protocol::SecretFetchedCallback& callback) {
-  if (!jni_runtime_->ui_task_runner()->BelongsToCurrentThread()) {
-    jni_runtime_->ui_task_runner()->PostTask(
-        FROM_HERE, base::Bind(&JniPairingSecretFetcher::FetchSecret,
-                              secret_fetcher_, pairable, callback));
-  } else if (secret_fetcher_) {
-    secret_fetcher_->FetchSecret(pairable, callback);
-  }
-}
-
 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,
                               GetWeakPtr(), device_name));
     return;
   }
 
   device_name_ = device_name;
 }
@@ skipping 61 matching lines @@
   video_renderer_.reset();
   view_.reset();
   signaling_.reset();
   perf_tracker_.reset();
   client_context_.reset();
 
   weak_factory_.InvalidateWeakPtrs();
 }
 
 }  // namespace remoting