[Android Client] Move session-scoped native interface into JniClient

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 <utility>
 
 #include "base/bind.h"
 #include "base/callback_helpers.h"
 #include "base/format_macros.h"
 #include "base/logging.h"
 #include "base/memory/ptr_util.h"
 #include "jingle/glue/thread_wrapper.h"
 #include "net/socket/client_socket_factory.h"
 #include "remoting/base/chromium_url_request.h"
 #include "remoting/client/audio_player_android.h"
 #include "remoting/client/client_telemetry_logger.h"
 #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_frame_consumer.h"
 #include "remoting/client/software_video_renderer.h"
 #include "remoting/protocol/chromium_port_allocator_factory.h"
 #include "remoting/protocol/chromium_socket_factory.h"
 #include "remoting/protocol/client_authentication_config.h"
 #include "remoting/protocol/host_stub.h"
 #include "remoting/protocol/network_settings.h"
 #include "remoting/protocol/performance_tracker.h"
 #include "remoting/protocol/transport_context.h"
 #include "remoting/signaling/server_log_entry.h"
 #include "ui/events/keycodes/dom/keycode_converter.h"
 
 namespace remoting {
 
 namespace {
 
 // TODO(solb) Move into location shared with client plugin.
 const char* const kXmppServer = "talk.google.com";
 const int kXmppPort = 5222;
 const bool kXmppUseTls = true;
 
 // Interval at which to log performance statistics, if enabled.
 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)
     : jni_runtime_(jni_runtime),
+      jni_client_(jni_client),
       host_jid_(host_jid),
       flags_(flags),
       capabilities_(capabilities),
       weak_factory_(this) {
   DCHECK(jni_runtime_->ui_task_runner()->BelongsToCurrentThread());
 
   // Initialize XMPP config.
   xmpp_config_.host = kXmppServer;
   xmpp_config_.port = kXmppPort;
   xmpp_config_.use_tls = kXmppUseTls;
@@ skipping 64 matching lines @@
     const protocol::ThirdPartyTokenFetchedCallback& token_fetched_callback) {
   DCHECK(jni_runtime_->network_task_runner()->BelongsToCurrentThread());
   DCHECK(third_party_token_fetched_callback_.is_null());
 
   __android_log_print(ANDROID_LOG_INFO,
                       "ThirdPartyAuth",
                       "Fetching Third Party Token from user.");
 
   third_party_token_fetched_callback_ = token_fetched_callback;
   jni_runtime_->ui_task_runner()->PostTask(
-      FROM_HERE, base::Bind(&ChromotingJniRuntime::FetchThirdPartyToken,
-                            base::Unretained(jni_runtime_), token_url,
+      FROM_HERE, base::Bind(&JniClient::FetchThirdPartyToken,
+                            jni_client_->GetWeakPtr(), token_url,
                             host_public_key, scope));
 }
 
 void ChromotingJniInstance::HandleOnThirdPartyTokenFetched(
     const std::string& token,
     const std::string& shared_secret) {
   DCHECK(jni_runtime_->network_task_runner()->BelongsToCurrentThread());
 
   __android_log_print(
       ANDROID_LOG_INFO, "ThirdPartyAuth", "Third Party Token Fetched.");
@@ skipping 25 matching lines @@
 }
 
 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_runtime_->RedrawCanvas();
+  jni_client_->RedrawCanvas();
 }
 
 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,
                               this, x, y, button, button_down));
@@ skipping 113 matching lines @@
 
   if (create_pairing_ && state == protocol::ConnectionToHost::CONNECTED) {
     protocol::PairingRequest request;
     DCHECK(!device_name_.empty());
     request.set_client_name(device_name_);
     client_->host_stub()->RequestPairing(request);
   }
 
   jni_runtime_->ui_task_runner()->PostTask(
       FROM_HERE,
-      base::Bind(&ChromotingJniRuntime::OnConnectionState,
-                 base::Unretained(jni_runtime_),
+      base::Bind(&JniClient::OnConnectionState,
+                 jni_client_->GetWeakPtr(),
                  state,
                  error));
 }
 
 void ChromotingJniInstance::OnConnectionReady(bool ready) {
   // We ignore this message, since OnConnectionState tells us the same thing.
 }
 
 void ChromotingJniInstance::OnRouteChanged(
     const std::string& channel_name,
     const protocol::TransportRoute& route) {
   std::string message = "Channel " + channel_name + " using " +
       protocol::TransportRoute::GetTypeString(route.type) + " connection.";
   __android_log_print(ANDROID_LOG_INFO, "route", "%s", message.c_str());
 }
 
 void ChromotingJniInstance::SetCapabilities(const std::string& capabilities) {
   jni_runtime_->ui_task_runner()->PostTask(
-      FROM_HERE, base::Bind(&ChromotingJniRuntime::SetCapabilities,
-                            base::Unretained(jni_runtime_), capabilities));
+      FROM_HERE, base::Bind(&JniClient::SetCapabilities,
+                            jni_client_->GetWeakPtr(), capabilities));
 }
 
 void ChromotingJniInstance::SetPairingResponse(
     const protocol::PairingResponse& response) {
   jni_runtime_->ui_task_runner()->PostTask(
       FROM_HERE,
-      base::Bind(&ChromotingJniRuntime::CommitPairingCredentials,
-                 base::Unretained(jni_runtime_), client_auth_config_.host_id,
+      base::Bind(&JniClient::CommitPairingCredentials,
+                 jni_client_->GetWeakPtr(), 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(&ChromotingJniRuntime::HandleExtensionMessage,
-                            base::Unretained(jni_runtime_), message.type(),
+      FROM_HERE, base::Bind(&JniClient::HandleExtensionMessage,
+                            jni_client_->GetWeakPtr(), message.type(),
                             message.data()));
 }
 
 void ChromotingJniInstance::SetDesktopSize(const webrtc::DesktopSize& size,
                                            const webrtc::DesktopVector& dpi) {
   // JniFrameConsumer get size from the frames and it doesn't use DPI, so this
   // call can be ignored.
 }
 
 protocol::ClipboardStub* ChromotingJniInstance::GetClipboardStub() {
@@ skipping 11 matching lines @@
 
 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;
   }
 
-  jni_runtime_->UpdateCursorShape(shape);
+  jni_client_->UpdateCursorShape(shape);
 }
 
 void ChromotingJniInstance::ConnectToHostOnNetworkThread() {
   DCHECK(jni_runtime_->network_task_runner()->BelongsToCurrentThread());
 
   jingle_glue::JingleThreadWrapper::EnsureForCurrentMessageLoop();
 
   client_context_.reset(new ClientContext(jni_runtime_->network_task_runner()));
   client_context_->Start();
 
   perf_tracker_.reset(new protocol::PerformanceTracker());
 
-  view_.reset(new JniFrameConsumer(jni_runtime_));
+  view_.reset(new JniFrameConsumer(jni_runtime_, jni_client_));
   video_renderer_.reset(new SoftwareVideoRenderer(
       client_context_->decode_task_runner(), view_.get(), perf_tracker_.get()));
 
   client_.reset(
       new ChromotingClient(client_context_.get(), this, video_renderer_.get(),
                            base::WrapUnique(new AudioPlayerAndroid())));
 
   signaling_.reset(
       new XmppSignalStrategy(net::ClientSocketFactory::GetDefaultFactory(),
                              jni_runtime_->url_requester(), xmpp_config_));
@@ skipping 26 matching lines @@
     bool pairable,
     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;
   }
 
   // Delete pairing credentials if they exist.
-  jni_runtime_->CommitPairingCredentials(client_auth_config_.host_id, "", "");
+  jni_client_->CommitPairingCredentials(client_auth_config_.host_id, "", "");
 
   pin_callback_ = callback;
-  jni_runtime_->DisplayAuthenticationPrompt(pairable);
+  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));
     return;
   }
 
@@ skipping 50 matching lines @@
       perf_tracker_->round_trip_ms().Max());
 
   jni_runtime_->logger()->LogStatistics(perf_tracker_.get());
 
   jni_runtime_->network_task_runner()->PostDelayedTask(
       FROM_HERE, base::Bind(&ChromotingJniInstance::LogPerfStats, this),
       base::TimeDelta::FromMilliseconds(kPerfStatsIntervalMs));
 }
 
 }  // namespace remoting