Revert of Move NegotiatingClientAuthentication creation to 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 <stdint.h>
 
 #include <utility>
@@ skipping 39 matching lines @@
                                              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),
+      host_id_(host_id),
       host_jid_(host_jid),
       flags_(flags),
+      create_pairing_(false),
+      stats_logging_enabled_(false),
       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;
   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, weak_factory_.GetWeakPtr());
-  client_auth_config_.fetch_third_party_token_callback =
+  // Initialize |authenticator_|.
+  authenticator_.reset(new protocol::NegotiatingClientAuthenticator(
+      pairing_id, pairing_secret, host_id_,
+      base::Bind(&ChromotingJniInstance::FetchSecret,
+                 weak_factory_.GetWeakPtr()),
       base::Bind(&ChromotingJniInstance::FetchThirdPartyToken,
-                 weak_factory_.GetWeakPtr(), host_pubkey);
+                 weak_factory_.GetWeakPtr(), host_pubkey)));
 
   // Post a task to start connection
   jni_runtime_->network_task_runner()->PostTask(
       FROM_HERE,
       base::Bind(&ChromotingJniInstance::ConnectToHostOnNetworkThread, this));
 }
 
 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(!authenticator_);
   DCHECK(!client_);
   DCHECK(!signaling_);
   DCHECK(!client_status_logger_);
 }
 
 void ChromotingJniInstance::Disconnect() {
   if (!jni_runtime_->network_task_runner()->BelongsToCurrentThread()) {
     jni_runtime_->network_task_runner()->PostTask(
         FROM_HERE,
         base::Bind(&ChromotingJniInstance::Disconnect, this));
     return;
   }
 
+  host_id_.clear();
+
   stats_logging_enabled_ = false;
 
   // |client_| must be torn down before |signaling_|.
   client_.reset();
   client_status_logger_.reset();
   video_renderer_.reset();
   view_.reset();
+  authenticator_.reset();
   signaling_.reset();
   perf_tracker_.reset();
   client_context_.reset();
 }
 
 void ChromotingJniInstance::FetchThirdPartyToken(
     const std::string& host_public_key,
     const std::string& token_url,
     const std::string& scope,
     const protocol::ThirdPartyTokenFetchedCallback& token_fetched_callback) {
@@ skipping 195 matching lines @@
 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(&ChromotingJniRuntime::SetCapabilities,
+                 base::Unretained(jni_runtime_),
+                 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,
-                 response.client_id(), response.shared_secret()));
+                 base::Unretained(jni_runtime_),
+                 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(),
-                            message.data()));
+      FROM_HERE,
+      base::Bind(&ChromotingJniRuntime::HandleExtensionMessage,
+                 base::Unretained(jni_runtime_),
+                 message.type(),
+                 message.data()));
 }
 
 protocol::ClipboardStub* ChromotingJniInstance::GetClipboardStub() {
   return this;
 }
 
 protocol::CursorShapeStub* ChromotingJniInstance::GetCursorShapeStub() {
   return this;
 }
 
@@ skipping 21 matching lines @@
 
   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_));
   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(), nullptr));
+  client_.reset(new ChromotingClient(
+      client_context_.get(), this, video_renderer_.get(), nullptr));
 
-  signaling_.reset(
-      new XmppSignalStrategy(net::ClientSocketFactory::GetDefaultFactory(),
-                             jni_runtime_->url_requester(), xmpp_config_));
+  signaling_.reset(new XmppSignalStrategy(
+      net::ClientSocketFactory::GetDefaultFactory(),
+      jni_runtime_->url_requester(), xmpp_config_));
 
   client_status_logger_.reset(
-      new ClientStatusLogger(ServerLogEntry::ME2ME, signaling_.get(),
+      new ClientStatusLogger(ServerLogEntry::ME2ME,
+                             signaling_.get(),
                              ServiceUrls::GetInstance()->directory_bot_jid()));
 
   scoped_refptr<protocol::TransportContext> transport_context =
       new protocol::TransportContext(
           signaling_.get(),
           make_scoped_ptr(new protocol::ChromiumPortAllocatorFactory()),
           make_scoped_ptr(
               new ChromiumUrlRequestFactory(jni_runtime_->url_requester())),
           protocol::NetworkSettings(
               protocol::NetworkSettings::NAT_TRAVERSAL_FULL),
           protocol::TransportRole::CLIENT);
 
   if (flags_.find("useWebrtc") != std::string::npos) {
     VLOG(0) << "Attempting to connect using WebRTC.";
     scoped_ptr<protocol::CandidateSessionConfig> protocol_config =
         protocol::CandidateSessionConfig::CreateEmpty();
     protocol_config->set_webrtc_supported(true);
     protocol_config->set_ice_supported(false);
     client_->set_protocol_config(std::move(protocol_config));
   }
 
-  client_->Start(signaling_.get(), client_auth_config_, transport_context,
+  client_->Start(signaling_.get(), std::move(authenticator_), 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(&ChromotingJniInstance::FetchSecret,
                               this, pairable, callback));
     return;
   }
 
   // Delete pairing credentials if they exist.
-  jni_runtime_->CommitPairingCredentials(client_auth_config_.host_id, "", "");
+  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));
@@ skipping 45 matching lines @@
       perf_tracker_->round_trip_ms());
 
   client_status_logger_->LogStatistics(perf_tracker_.get());
 
   jni_runtime_->network_task_runner()->PostDelayedTask(
       FROM_HERE, base::Bind(&ChromotingJniInstance::LogPerfStats, this),
       base::TimeDelta::FromMilliseconds(kPerfStatsIntervalMs));
 }
 
 }  // namespace remoting