Move NegotiatingClientAuthentication creation to ChromotingClient.

remoting/client/plugin/chromoting_instance.cc

 // Copyright (c) 2012 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/plugin/chromoting_instance.h"
 
 #include <nacl_io/nacl_io.h>
 #include <sys/mount.h>
 
 #include <string>
@@ skipping 561 matching lines @@
   pp::VarDictionary dictionary;
   dictionary.Set(pp::Var("width"), cursor_shape.width());
   dictionary.Set(pp::Var("height"), cursor_shape.height());
   dictionary.Set(pp::Var("hotspotX"), cursor_shape.hotspot_x());
   dictionary.Set(pp::Var("hotspotY"), cursor_shape.hotspot_y());
   dictionary.Set(pp::Var("data"), array_buffer);
   PostChromotingMessage("setCursorShape", dictionary);
 }
 
 void ChromotingInstance::HandleConnect(const base::DictionaryValue& data) {
+  protocol::ClientAuthenticationConfig client_auth_config;
+
   std::string local_jid;
   std::string host_jid;
   std::string host_public_key;
-  std::string authentication_tag;
   if (!data.GetString("hostJid", &host_jid) ||
       !data.GetString("hostPublicKey", &host_public_key) ||
       !data.GetString("localJid", &local_jid) ||
-      !data.GetString("authenticationTag", &authentication_tag)) {
+      !data.GetString("hostId", &client_auth_config.host_id)) {
     LOG(ERROR) << "Invalid connect() data.";
     return;
   }
 
-  std::string client_pairing_id;
-  data.GetString("clientPairingId", &client_pairing_id);
-  std::string client_paired_secret;
-  data.GetString("clientPairedSecret", &client_paired_secret);
+  data.GetString("clientPairingId", &client_auth_config.pairing_client_id);
+  data.GetString("clientPairedSecret", &client_auth_config.pairing_secret);
 
-  protocol::FetchSecretCallback fetch_secret_callback;
   if (use_async_pin_dialog_) {
-    fetch_secret_callback = base::Bind(
+    client_auth_config.fetch_secret_callback = base::Bind(
         &ChromotingInstance::FetchSecretFromDialog, weak_factory_.GetWeakPtr());
   } else {
     std::string shared_secret;
     if (!data.GetString("sharedSecret", &shared_secret)) {
       LOG(ERROR) << "sharedSecret not specified in connect().";
       return;
     }
-    fetch_secret_callback =
+    client_auth_config.fetch_secret_callback =
         base::Bind(&ChromotingInstance::FetchSecretFromString, shared_secret);
   }
 
+  client_auth_config.fetch_third_party_token_callback =
+      base::Bind(&ChromotingInstance::FetchThirdPartyToken,
+                 weak_factory_.GetWeakPtr(), host_public_key);
+
   // Read the list of capabilities, if any.
   std::string capabilities;
   if (data.HasKey("capabilities")) {
     if (!data.GetString("capabilities", &capabilities)) {
       LOG(ERROR) << "Invalid connect() data.";
       return;
     }
   }
 
   // Read and parse list of experiments.
@@ skipping 65 matching lines @@
   // Create TransportContext.
   scoped_refptr<protocol::TransportContext> transport_context(
       new protocol::TransportContext(
           signal_strategy_.get(),
           make_scoped_ptr(new PepperPortAllocatorFactory(this)),
           make_scoped_ptr(new PepperUrlRequestFactory(this)),
           protocol::NetworkSettings(
               protocol::NetworkSettings::NAT_TRAVERSAL_FULL),
           protocol::TransportRole::CLIENT));
 
-  // Create Authenticator.
-  protocol::FetchThirdPartyTokenCallback fetch_third_party_token_callback =
-      base::Bind(&ChromotingInstance::FetchThirdPartyToken,
-                 weak_factory_.GetWeakPtr(), host_public_key);
-
-  scoped_ptr<protocol::Authenticator> authenticator(
-      new protocol::NegotiatingClientAuthenticator(
-          client_pairing_id, client_paired_secret, authentication_tag,
-          fetch_secret_callback, fetch_third_party_token_callback));
-
   scoped_ptr<protocol::CandidateSessionConfig> config =
       protocol::CandidateSessionConfig::CreateDefault();
   if (std::find(experiments_list.begin(), experiments_list.end(), "vp9") !=
       experiments_list.end()) {
     config->set_vp9_experiment_enabled(true);
   }
   client_->set_protocol_config(std::move(config));
 
   // Kick off the connection.
-  client_->Start(signal_strategy_.get(), std::move(authenticator),
-                 transport_context, host_jid, capabilities);
+  client_->Start(signal_strategy_.get(), client_auth_config, transport_context,
+                 host_jid, capabilities);
 
   // Connect the input pipeline to the protocol stub.
   mouse_input_filter_.set_input_stub(client_->input_stub());
   if (!plugin_view_.is_null()) {
     webrtc::DesktopSize size(plugin_view_.GetRect().width(),
                              plugin_view_.GetRect().height());
     mouse_input_filter_.set_input_size(size);
     touch_input_scaler_.set_input_size(size);
   }
 
@@ skipping 411 matching lines @@
   if (is_custom_counts_histogram) {
     uma.HistogramCustomCounts(histogram_name, value, histogram_min,
                               histogram_max, histogram_buckets);
   } else {
     uma.HistogramCustomTimes(histogram_name, value, histogram_min,
                              histogram_max, histogram_buckets);
   }
 }
 
 }  // namespace remoting