Support LCS signaling address in the Host.

remoting/protocol/jingle_session.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.h"
 
 #include <stdint.h>
 
 #include <limits>
 #include <utility>
@@ skipping 78 matching lines @@
   return error_;
 }
 
 void JingleSession::StartConnection(
     const std::string& peer_jid,
     std::unique_ptr<Authenticator> authenticator) {
   DCHECK(thread_checker_.CalledOnValidThread());
   DCHECK(authenticator.get());
   DCHECK_EQ(authenticator->state(), Authenticator::MESSAGE_READY);
 
-  peer_jid_ = peer_jid;
+  peer_ = Address(peer_jid);
   authenticator_ = std::move(authenticator);
 
   // Generate random session ID. There are usually not more than 1
   // concurrent session per host, so a random 64-bit integer provides
   // enough entropy. In the worst case connection will fail when two
   // clients generate the same session ID concurrently.
   session_id_ = base::Uint64ToString(
       base::RandGenerator(std::numeric_limits<uint64_t>::max()));
 
   // Send session-initiate message.
-  JingleMessage message(peer_jid_, JingleMessage::SESSION_INITIATE,
+  JingleMessage message(peer_, JingleMessage::SESSION_INITIATE,
                         session_id_);
   message.initiator = session_manager_->signal_strategy_->GetLocalJid();
   message.description.reset(new ContentDescription(
       session_manager_->protocol_config_->Clone(),
       authenticator_->GetNextMessage()));
   SendMessage(message);
 
   SetState(CONNECTING);
 }
 
 void JingleSession::InitializeIncomingConnection(
     const JingleMessage& initiate_message,
     std::unique_ptr<Authenticator> authenticator) {
   DCHECK(thread_checker_.CalledOnValidThread());
   DCHECK(initiate_message.description.get());
   DCHECK(authenticator.get());
   DCHECK_EQ(authenticator->state(), Authenticator::WAITING_MESSAGE);
 
-  peer_jid_ = initiate_message.from;
+  peer_ = initiate_message.from;
   authenticator_ = std::move(authenticator);
   session_id_ = initiate_message.sid;
 
   SetState(ACCEPTING);
 
   config_ =
       SessionConfig::SelectCommon(initiate_message.description->config(),
                                   session_manager_->protocol_config_.get());
   if (!config_) {
-    LOG(WARNING) << "Rejecting connection from " << peer_jid_
+    LOG(WARNING) << "Rejecting connection from " << peer_.endpoint_id
                  << " because no compatible configuration has been found.";
     Close(INCOMPATIBLE_PROTOCOL);
     return;
   }
 }
 
 void JingleSession::AcceptIncomingConnection(
     const JingleMessage& initiate_message) {
   DCHECK(config_);
 
@@ skipping 14 matching lines @@
 }
 
 void JingleSession::ContinueAcceptIncomingConnection() {
   DCHECK_NE(authenticator_->state(), Authenticator::PROCESSING_MESSAGE);
   if (authenticator_->state() == Authenticator::REJECTED) {
     Close(AuthRejectionReasonToErrorCode(authenticator_->rejection_reason()));
     return;
   }
 
   // Send the session-accept message.
-  JingleMessage message(peer_jid_, JingleMessage::SESSION_ACCEPT,
+  JingleMessage message(peer_, JingleMessage::SESSION_ACCEPT,
                         session_id_);
 
   std::unique_ptr<buzz::XmlElement> auth_message;
   if (authenticator_->state() == Authenticator::MESSAGE_READY)
     auth_message = authenticator_->GetNextMessage();
 
   message.description.reset(new ContentDescription(
       CandidateSessionConfig::CreateFrom(*config_), std::move(auth_message)));
   SendMessage(message);
 
   // Update state.
   SetState(ACCEPTED);
 
   if (authenticator_->state() == Authenticator::ACCEPTED) {
     OnAuthenticated();
   } else {
     DCHECK_EQ(authenticator_->state(), Authenticator::WAITING_MESSAGE);
     if (authenticator_->started()) {
       SetState(AUTHENTICATING);
     }
   }
 }
 
 const std::string& JingleSession::jid() {
   DCHECK(thread_checker_.CalledOnValidThread());
-  return peer_jid_;
+  // Returns the |endpoint_id| instead of the |jid| it uniquely identifies the
+  // peer.
+  return peer_.endpoint_id;
 }
 
 const SessionConfig& JingleSession::config() {
   DCHECK(thread_checker_.CalledOnValidThread());
   return *config_;
 }
 
 void JingleSession::SetTransport(Transport* transport) {
   DCHECK(thread_checker_.CalledOnValidThread());
   DCHECK(!transport_);
   DCHECK(transport);
   transport_ = transport;
 }
 
 void JingleSession::SendTransportInfo(
     std::unique_ptr<buzz::XmlElement> transport_info) {
   DCHECK(thread_checker_.CalledOnValidThread());
   DCHECK_EQ(state_, AUTHENTICATED);
 
-  JingleMessage message(peer_jid_, JingleMessage::TRANSPORT_INFO, session_id_);
+  JingleMessage message(peer_, JingleMessage::TRANSPORT_INFO, session_id_);
   message.transport_info = std::move(transport_info);
 
   std::unique_ptr<IqRequest> request = session_manager_->iq_sender()->SendIq(
       message.ToXml(), base::Bind(&JingleSession::OnTransportInfoResponse,
                                   base::Unretained(this)));
   if (request) {
     request->SetTimeout(base::TimeDelta::FromSeconds(kTransportInfoTimeout));
     transport_info_requests_.push_back(request.release());
   } else {
     LOG(ERROR) << "Failed to send a transport-info message";
@@ skipping 23 matching lines @@
       case MAX_SESSION_LENGTH:
         reason = JingleMessage::EXPIRED;
         break;
       case HOST_CONFIGURATION_ERROR:
         reason = JingleMessage::FAILED_APPLICATION;
         break;
       default:
         reason = JingleMessage::GENERAL_ERROR;
     }
 
-    JingleMessage message(peer_jid_, JingleMessage::SESSION_TERMINATE,
-                          session_id_);
+    JingleMessage message(peer_, JingleMessage::SESSION_TERMINATE, session_id_);
     message.reason = reason;
     SendMessage(message);
   }
 
   error_ = error;
 
   if (state_ != FAILED && state_ != CLOSED) {
     if (error != OK) {
       SetState(FAILED);
     } else {
@@ skipping 87 matching lines @@
     LOG(ERROR) << "Received error in response to transport-info message: \""
                << response->Str() << "\". Terminating the session.";
     Close(PEER_IS_OFFLINE);
   }
 }
 
 void JingleSession::OnIncomingMessage(const JingleMessage& message,
                                       const ReplyCallback& reply_callback) {
   DCHECK(thread_checker_.CalledOnValidThread());
 
-  if (message.from != peer_jid_) {
+  if (peer_ != message.from) {
     // Ignore messages received from a different Jid.
     reply_callback.Run(JingleMessageReply::INVALID_SID);
     return;
   }
 
   switch (message.action) {
     case JingleMessage::SESSION_ACCEPT:
       OnAccept(message, reply_callback);
       break;
 
@@ skipping 147 matching lines @@
   DCHECK_NE(authenticator_->state(), Authenticator::PROCESSING_MESSAGE);
 
   if (state_ != ACCEPTED && state_ != AUTHENTICATING) {
     DCHECK(state_ == FAILED || state_ == CLOSED);
     // The remote host closed the connection while the authentication was being
     // processed asynchronously, nothing to do.
     return;
   }
 
   if (authenticator_->state() == Authenticator::MESSAGE_READY) {
-    JingleMessage message(peer_jid_, JingleMessage::SESSION_INFO, session_id_);
+    JingleMessage message(peer_, JingleMessage::SESSION_INFO, session_id_);
     message.info = authenticator_->GetNextMessage();
     DCHECK(message.info.get());
     SendMessage(message);
   }
   DCHECK_NE(authenticator_->state(), Authenticator::MESSAGE_READY);
 
   // The current JingleSession object can be destroyed by event_handler of
   // SetState(AUTHENTICATING) and cause subsequent dereferencing of the this
   // pointer to crash.  To protect against it, we run ContinueAuthenticationStep
   // asychronously using a weak pointer.
@@ skipping 37 matching lines @@
   }
 }
 
 bool JingleSession::is_session_active() {
   return state_ == CONNECTING || state_ == ACCEPTING || state_ == ACCEPTED ||
         state_ == AUTHENTICATING || state_ == AUTHENTICATED;
 }
 
 }  // namespace protocol
 }  // namespace remoting