Use SignalingAddress in SignalStrategy insterface.

remoting/client/chromoting_client.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/chromoting_client.h"
 
 #include <utility>
 
 #include "base/memory/ptr_util.h"
 #include "remoting/base/capabilities.h"
@@ skipping 215 matching lines @@
   VLOG(0) << "Using " << protocol::TransportRoute::GetTypeString(route.type)
           << " connection for " << channel_name << " channel";
   user_interface_->OnRouteChanged(channel_name, route);
 }
 
 void ChromotingClient::OnSignalStrategyStateChange(
     SignalStrategy::State state) {
   DCHECK(thread_checker_.CalledOnValidThread());
 
   if (state == SignalStrategy::CONNECTED) {
-    VLOG(1) << "Connected as: " << signal_strategy_->GetLocalJid();
+    VLOG(1) << "Connected as: " << signal_strategy_->GetLocalAddress().jid();
     // After signaling has been connected we can try connecting to the host.
     if (connection_ &&
         connection_->state() == protocol::ConnectionToHost::INITIALIZING) {
       StartConnection();
     }
   } else if (state == SignalStrategy::DISCONNECTED) {
     VLOG(1) << "Signaling connection closed.";
     connection_.reset();
     user_interface_->OnConnectionState(protocol::ConnectionToHost::CLOSED,
                                        protocol::SIGNALING_ERROR);
   }
 }
 
 bool ChromotingClient::OnSignalStrategyIncomingStanza(
     const buzz::XmlElement* stanza) {
   return false;
 }
 
 void ChromotingClient::StartConnection() {
   DCHECK(thread_checker_.CalledOnValidThread());
   auto session = session_manager_->Connect(
-      host_jid_, base::MakeUnique<protocol::NegotiatingClientAuthenticator>(
-                     NormalizeJid(signal_strategy_->GetLocalJid()), host_jid_,
-                     client_auth_config_));
+      SignalingAddress(host_jid_),
+      base::MakeUnique<protocol::NegotiatingClientAuthenticator>(
+          signal_strategy_->GetLocalAddress().id(), host_jid_,
+          client_auth_config_));
   if (host_experiment_sender_) {
     session->AddPlugin(host_experiment_sender_.get());
   }
   connection_->Connect(std::move(session), transport_context_, this);
 }
 
 void ChromotingClient::OnChannelsConnected() {
   DCHECK(thread_checker_.CalledOnValidThread());
 
   // Negotiate capabilities with the host.
   VLOG(1) << "Client capabilities: " << local_capabilities_;
 
   protocol::Capabilities capabilities;
   capabilities.set_capabilities(local_capabilities_);
   connection_->host_stub()->SetCapabilities(capabilities);
 
   mouse_input_scaler_.set_input_stub(connection_->input_stub());
 }
 
 }  // namespace remoting