Cleanups in ChromotingClient

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 "base/bind.h"
 #include "base/logging.h"
 #include "jingle/glue/thread_wrapper.h"
 #include "net/socket/client_socket_factory.h"
 #include "remoting/base/service_urls.h"
 #include "remoting/client/audio_player.h"
 #include "remoting/client/client_status_logger.h"
 #include "remoting/client/jni/android_keymap.h"
 #include "remoting/client/jni/chromoting_jni_runtime.h"
 #include "remoting/client/software_video_renderer.h"
 #include "remoting/client/token_fetcher_proxy.h"
 #include "remoting/jingle_glue/chromium_port_allocator.h"
 #include "remoting/jingle_glue/chromium_socket_factory.h"
 #include "remoting/jingle_glue/network_settings.h"
 #include "remoting/jingle_glue/server_log_entry.h"
 #include "remoting/protocol/host_stub.h"
 #include "remoting/protocol/libjingle_transport_factory.h"
+#include "remoting/protocol/negotiating_client_authenticator.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,
                                              const char* username,
                                              const char* auth_token,
                                              const char* host_jid,
                                              const char* host_id,
                                              const char* host_pubkey,
                                              const char* pairing_id,
                                              const char* pairing_secret)
     : jni_runtime_(jni_runtime),
       host_id_(host_id),
+      host_jid_(host_jid),
       create_pairing_(false),
       stats_logging_enabled_(false),
       weak_factory_(this) {
   DCHECK(jni_runtime_->ui_task_runner()->BelongsToCurrentThread());
 
   // Intialize XMPP config.
   xmpp_config_.host = kXmppServer;
   xmpp_config_.port = kXmppPort;
   xmpp_config_.use_tls = kXmppUseTls;
   xmpp_config_.username = username;
   xmpp_config_.auth_token = auth_token;
   xmpp_config_.auth_service = "oauth2";
 
-  // Initialize ClientConfig.
-  client_config_.host_jid = host_jid;
-  client_config_.host_public_key = host_pubkey;
+  // Initialize |authenticator_|.
+  scoped_ptr<protocol::ThirdPartyClientAuthenticator::TokenFetcher>
+      token_fetcher(new TokenFetcherProxy(
+          base::Bind(&ChromotingJniInstance::FetchThirdPartyToken,
+                     weak_factory_.GetWeakPtr()),
+          host_pubkey));
 
-  client_config_.fetch_secret_callback =
-      base::Bind(&ChromotingJniInstance::FetchSecret, this);
-  client_config_.authentication_tag = host_id_;
+  std::vector<protocol::AuthenticationMethod> auth_methods;
+  auth_methods.push_back(protocol::AuthenticationMethod::Spake2Pair());
+  auth_methods.push_back(protocol::AuthenticationMethod::Spake2(
+      protocol::AuthenticationMethod::HMAC_SHA256));
+  auth_methods.push_back(protocol::AuthenticationMethod::Spake2(
+      protocol::AuthenticationMethod::NONE));
 
-  client_config_.client_pairing_id = pairing_id;
-  client_config_.client_paired_secret = pairing_secret;
-
-  client_config_.authentication_methods.push_back(
-      protocol::AuthenticationMethod::FromString("spake2_pair"));
-  client_config_.authentication_methods.push_back(
-      protocol::AuthenticationMethod::FromString("spake2_hmac"));
-  client_config_.authentication_methods.push_back(
-      protocol::AuthenticationMethod::FromString("spake2_plain"));
+  authenticator_.reset(new protocol::NegotiatingClientAuthenticator(
+      pairing_id, pairing_secret, host_id_,
+      base::Bind(&ChromotingJniInstance::FetchSecret, this),
+      token_fetcher.Pass(), auth_methods));
 
   // Post a task to start connection
   jni_runtime_->display_task_runner()->PostTask(
       FROM_HERE,
       base::Bind(&ChromotingJniInstance::ConnectToHostOnDisplayThread,
                  this));
 }
 
 ChromotingJniInstance::~ChromotingJniInstance() {}
 
@@ skipping 95 matching lines @@
     return;
   }
 
   protocol::MouseEvent event;
   event.set_x(x);
   event.set_y(y);
   event.set_button(button);
   if (button != protocol::MouseEvent::BUTTON_UNDEFINED)
     event.set_button_down(button_down);
 
-  connection_->input_stub()->InjectMouseEvent(event);
+  client_->input_stub()->InjectMouseEvent(event);
 }
 
 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));
     return;
   }
 
   protocol::MouseEvent event;
   event.set_wheel_delta_x(delta_x);
   event.set_wheel_delta_y(delta_y);
-  connection_->input_stub()->InjectMouseEvent(event);
+  client_->input_stub()->InjectMouseEvent(event);
 }
 
 bool ChromotingJniInstance::SendKeyEvent(int key_code, bool key_down) {
   uint32 usb_key_code = AndroidKeycodeToUsbKeycode(key_code);
   if (!usb_key_code) {
     LOG(WARNING) << "Ignoring unknown keycode: " << key_code;
     return false;
   }
 
   SendKeyEventInternal(usb_key_code, key_down);
   return true;
 }
 
 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));
     return;
   }
 
   protocol::TextEvent event;
   event.set_text(text);
-  connection_->input_stub()->InjectTextEvent(event);
+  client_->input_stub()->InjectTextEvent(event);
 }
 
 void ChromotingJniInstance::RecordPaintTime(int64 paint_time_ms) {
   if (!jni_runtime_->network_task_runner()->BelongsToCurrentThread()) {
     jni_runtime_->network_task_runner()->PostTask(
         FROM_HERE, base::Bind(&ChromotingJniInstance::RecordPaintTime, this,
                               paint_time_ms));
     return;
   }
 
   if (stats_logging_enabled_)
     video_renderer_->GetStats()->video_paint_ms()->Record(paint_time_ms);
 }
 
 void ChromotingJniInstance::OnConnectionState(
     protocol::ConnectionToHost::State state,
     protocol::ErrorCode error) {
   DCHECK(jni_runtime_->network_task_runner()->BelongsToCurrentThread());
 
   EnableStatsLogging(state == protocol::ConnectionToHost::CONNECTED);
 
   client_status_logger_->LogSessionStateChange(state, error);
 
   if (create_pairing_ && state == protocol::ConnectionToHost::CONNECTED) {
     protocol::PairingRequest request;
     DCHECK(!device_name_.empty());
     request.set_client_name(device_name_);
-    connection_->host_stub()->RequestPairing(request);
+    client_->host_stub()->RequestPairing(request);
   }
 
   jni_runtime_->ui_task_runner()->PostTask(
       FROM_HERE,
       base::Bind(&ChromotingJniRuntime::ReportConnectionStatus,
                  base::Unretained(jni_runtime_),
                  state,
                  error));
 }
 
@@ skipping 29 matching lines @@
 }
 
 protocol::ClipboardStub* ChromotingJniInstance::GetClipboardStub() {
   return this;
 }
 
 protocol::CursorShapeStub* ChromotingJniInstance::GetCursorShapeStub() {
   return this;
 }
 
-scoped_ptr<protocol::ThirdPartyClientAuthenticator::TokenFetcher>
-    ChromotingJniInstance::GetTokenFetcher(const std::string& host_public_key) {
-  return scoped_ptr<protocol::ThirdPartyClientAuthenticator::TokenFetcher>(
-      new TokenFetcherProxy(
-          base::Bind(&ChromotingJniInstance::FetchThirdPartyToken,
-                     weak_factory_.GetWeakPtr()),
-          host_public_key));
-}
-
 void ChromotingJniInstance::InjectClipboardEvent(
     const protocol::ClipboardEvent& event) {
   NOTIMPLEMENTED();
 }
 
 void ChromotingJniInstance::SetCursorShape(
     const protocol::CursorShapeInfo& shape) {
   if (!jni_runtime_->display_task_runner()->BelongsToCurrentThread()) {
     jni_runtime_->display_task_runner()->PostTask(
         FROM_HERE,
@@ skipping 21 matching lines @@
 
 void ChromotingJniInstance::ConnectToHostOnNetworkThread() {
   DCHECK(jni_runtime_->network_task_runner()->BelongsToCurrentThread());
 
   jingle_glue::JingleThreadWrapper::EnsureForCurrentMessageLoop();
 
   client_context_.reset(new ClientContext(
       jni_runtime_->network_task_runner().get()));
   client_context_->Start();
 
-  connection_.reset(new protocol::ConnectionToHost(true));
-
   SoftwareVideoRenderer* renderer =
       new SoftwareVideoRenderer(client_context_->main_task_runner(),
                                 client_context_->decode_task_runner(),
                                 frame_consumer_);
   view_->set_frame_producer(renderer);
   video_renderer_.reset(renderer);
 
-  client_.reset(new ChromotingClient(
-      client_config_, client_context_.get(), connection_.get(),
-      this, video_renderer_.get(), scoped_ptr<AudioPlayer>()));
-
+  client_.reset(new ChromotingClient(client_context_.get(),
+                                     this,
+                                     video_renderer_.get(),
+                                     scoped_ptr<AudioPlayer>()));
 
   signaling_.reset(new XmppSignalStrategy(
       net::ClientSocketFactory::GetDefaultFactory(),
       jni_runtime_->url_requester(), xmpp_config_));
 
   client_status_logger_.reset(
       new ClientStatusLogger(ServerLogEntry::ME2ME,
                              signaling_.get(),
                              ServiceUrls::GetInstance()->directory_bot_jid()));
 
   NetworkSettings network_settings(NetworkSettings::NAT_TRAVERSAL_FULL);
 
   // Use Chrome's network stack to allocate ports for peer-to-peer channels.
   scoped_ptr<ChromiumPortAllocator> port_allocator(
       ChromiumPortAllocator::Create(jni_runtime_->url_requester(),
                                     network_settings));
 
   scoped_ptr<protocol::TransportFactory> transport_factory(
       new protocol::LibjingleTransportFactory(
           signaling_.get(),
           port_allocator.PassAs<cricket::HttpPortAllocatorBase>(),
           network_settings));
 
-  client_->Start(signaling_.get(), transport_factory.Pass());
+  client_->Start(signaling_.get(), authenticator_.Pass(),
+                 transport_factory.Pass(), host_jid_, std::string());
 }
 
 void ChromotingJniInstance::DisconnectFromHostOnNetworkThread() {
   DCHECK(jni_runtime_->network_task_runner()->BelongsToCurrentThread());
 
   host_id_.clear();
 
   stats_logging_enabled_ = false;
 
   // |client_| must be torn down before |signaling_|.
-  connection_.reset();
+  client_.reset();
   client_.reset();
   client_status_logger_.reset();
 }
 
 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(&ChromotingJniInstance::FetchSecret,
                               this, pairable, callback));
     return;
   }
 
-  if (!client_config_.client_pairing_id.empty()) {
-    // We attempted to connect using an existing pairing that was rejected.
-    // Unless we forget about the stale credentials, we'll continue trying them.
-    jni_runtime_->CommitPairingCredentials(host_id_, "", "");
-  }
+  // Delete pairing credentials if they exist.
+  jni_runtime_->CommitPairingCredentials(host_id_, "", "");
 
   pin_callback_ = callback;
   jni_runtime_->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;
   }
 
   device_name_ = device_name;
 }
 
 void ChromotingJniInstance::SendKeyEventInternal(int usb_key_code,
                                                  bool key_down) {
   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));
     return;
   }
 
 
   protocol::KeyEvent event;
   event.set_usb_keycode(usb_key_code);
   event.set_pressed(key_down);
-  connection_->input_stub()->InjectKeyEvent(event);
+  client_->input_stub()->InjectKeyEvent(event);
 }
 
 void ChromotingJniInstance::EnableStatsLogging(bool enabled) {
   DCHECK(jni_runtime_->network_task_runner()->BelongsToCurrentThread());
 
   if (enabled && !stats_logging_enabled_) {
     jni_runtime_->network_task_runner()->PostDelayedTask(
         FROM_HERE, base::Bind(&ChromotingJniInstance::LogPerfStats, this),
         base::TimeDelta::FromMilliseconds(kPerfStatsIntervalMs));
   }
@@ skipping 19 matching lines @@
                       stats->round_trip_ms()->Average());
 
   client_status_logger_->LogStatistics(stats);
 
   jni_runtime_->network_task_runner()->PostDelayedTask(
       FROM_HERE, base::Bind(&ChromotingJniInstance::LogPerfStats, this),
       base::TimeDelta::FromMilliseconds(kPerfStatsIntervalMs));
 }
 
 }  // namespace remoting