Use SignalingAddress in SignalStrategy insterface.

remoting/protocol/jingle_session_manager.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/protocol/jingle_session_manager.h"
 
 #include <utility>
 
 #include "base/bind.h"
 #include "remoting/protocol/authenticator.h"
@@ skipping 28 matching lines @@
     const IncomingSessionCallback& incoming_session_callback) {
   incoming_session_callback_ = incoming_session_callback;
 }
 
 void JingleSessionManager::set_protocol_config(
     std::unique_ptr<CandidateSessionConfig> config) {
   protocol_config_ = std::move(config);
 }
 
 std::unique_ptr<Session> JingleSessionManager::Connect(
-    const std::string& host_jid,
+    const SignalingAddress& peer_address,
     std::unique_ptr<Authenticator> authenticator) {
   std::unique_ptr<JingleSession> session(new JingleSession(this));
-  session->StartConnection(host_jid, std::move(authenticator));
+  session->StartConnection(peer_address, std::move(authenticator));
   sessions_[session->session_id_] = session.get();
   return std::move(session);
 }
 
 void JingleSessionManager::set_authenticator_factory(
     std::unique_ptr<AuthenticatorFactory> authenticator_factory) {
   DCHECK(CalledOnValidThread());
   authenticator_factory_ = std::move(authenticator_factory);
 }
 
@@ skipping 14 matching lines @@
   }
 
   if (message->action == JingleMessage::SESSION_INITIATE) {
     // Description must be present in session-initiate messages.
     DCHECK(message->description.get());
 
     SendReply(std::move(stanza_copy), JingleMessageReply::NONE);
 
     std::unique_ptr<Authenticator> authenticator =
         authenticator_factory_->CreateAuthenticator(
-            signal_strategy_->GetLocalJid(), message->from.id());
+            signal_strategy_->GetLocalAddress().id(), message->from.id());
 
     JingleSession* session = new JingleSession(this);
     session->InitializeIncomingConnection(*message,
                                           std::move(authenticator));
     sessions_[session->session_id_] = session;
 
     // Destroy the session if it was rejected due to incompatible protocol.
     if (session->state_ != Session::ACCEPTING) {
       delete session;
       DCHECK(sessions_.find(message->sid) == sessions_.end());
@@ skipping 49 matching lines @@
   signal_strategy_->SendStanza(
       JingleMessageReply(error).ToXml(original_stanza.get()));
 }
 
 void JingleSessionManager::SessionDestroyed(JingleSession* session) {
   sessions_.erase(session->session_id_);
 }
 
 }  // namespace protocol
 }  // namespace remoting