Use SignalingAddress in SignalStrategy insterface.

remoting/signaling/xmpp_signal_strategy.cc

 // Copyright 2014 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/signaling/xmpp_signal_strategy.h"
 
 #include <utility>
 #include <vector>
 
 #include "base/bind.h"
@@ skipping 12 matching lines @@
 #include "net/cert/cert_verifier.h"
 #include "net/cert/ct_policy_enforcer.h"
 #include "net/cert/multi_log_ct_verifier.h"
 #include "net/http/transport_security_state.h"
 #include "net/socket/client_socket_factory.h"
 #include "net/socket/client_socket_handle.h"
 #include "net/socket/ssl_client_socket.h"
 #include "net/url_request/url_request_context_getter.h"
 #include "remoting/base/buffered_socket_writer.h"
 #include "remoting/base/logging.h"
+#include "remoting/signaling/signaling_address.h"
 #include "remoting/signaling/xmpp_login_handler.h"
 #include "remoting/signaling/xmpp_stream_parser.h"
 #include "third_party/libjingle_xmpp/xmllite/xmlelement.h"
 
 // Use 50 seconds keep-alive interval, in case routers terminate
 // connections that are idle for more than a minute.
 const int kKeepAliveIntervalSeconds = 50;
 
 const int kReadBufferSize = 4096;
 
@@ skipping 17 matching lines @@
   Core(
       net::ClientSocketFactory* socket_factory,
       const scoped_refptr<net::URLRequestContextGetter>& request_context_getter,
       const XmppServerConfig& xmpp_server_config);
   ~Core() override;
 
   void Connect();
   void Disconnect();
   State GetState() const;
   Error GetError() const;
-  std::string GetLocalJid() const;
+  const SignalingAddress& GetLocalAddress() const;
   void AddListener(Listener* listener);
   void RemoveListener(Listener* listener);
   bool SendStanza(std::unique_ptr<buzz::XmlElement> stanza);
 
   void SetAuthInfo(const std::string& username,
                    const std::string& auth_token);
 
  private:
   enum class TlsState {
     // StartTls() hasn't been called. |socket_| is not encrypted.
@@ skipping 47 matching lines @@
 
   std::unique_ptr<net::StreamSocket> socket_;
   std::unique_ptr<BufferedSocketWriter> writer_;
   scoped_refptr<net::IOBuffer> read_buffer_;
   bool read_pending_ = false;
 
   TlsState tls_state_ = TlsState::NOT_REQUESTED;
 
   std::unique_ptr<XmppLoginHandler> login_handler_;
   std::unique_ptr<XmppStreamParser> stream_parser_;
-  std::string jid_;
+  SignalingAddress local_address_;
 
   Error error_ = OK;
 
   base::ObserverList<Listener, true> listeners_;
 
   base::RepeatingTimer keep_alive_timer_;
 
   base::ThreadChecker thread_checker_;
 
   DISALLOW_COPY_AND_ASSIGN(Core);
@@ skipping 70 matching lines @@
   } else {
     return DISCONNECTED;
   }
 }
 
 SignalStrategy::Error XmppSignalStrategy::Core::GetError() const {
   DCHECK(thread_checker_.CalledOnValidThread());
   return error_;
 }
 
-std::string XmppSignalStrategy::Core::GetLocalJid() const {
+const SignalingAddress& XmppSignalStrategy::Core::GetLocalAddress() const {
   DCHECK(thread_checker_.CalledOnValidThread());
-  return jid_;
+  return local_address_;
 }
 
 void XmppSignalStrategy::Core::AddListener(Listener* listener) {
   DCHECK(thread_checker_.CalledOnValidThread());
   listeners_.AddObserver(listener);
 }
 
 void XmppSignalStrategy::Core::RemoveListener(Listener* listener) {
   DCHECK(thread_checker_.CalledOnValidThread());
   listeners_.RemoveObserver(listener);
@@ skipping 78 matching lines @@
       base::Bind(&Core::OnTlsConnected, base::Unretained(this)));
   if (result != net::ERR_IO_PENDING)
     OnTlsConnected(result);
 }
 
 void XmppSignalStrategy::Core::OnHandshakeDone(
     const std::string& jid,
     std::unique_ptr<XmppStreamParser> parser) {
   DCHECK(thread_checker_.CalledOnValidThread());
 
-  jid_ = jid;
+  local_address_ = SignalingAddress(jid);
   stream_parser_ = std::move(parser);
   stream_parser_->SetCallbacks(
       base::Bind(&Core::OnStanza, base::Unretained(this)),
       base::Bind(&Core::OnParserError, base::Unretained(this)));
 
   // Don't need |login_handler_| anymore.
   login_handler_.reset();
 
   for (auto& observer : listeners_)
     observer.OnSignalStrategyStateChange(CONNECTED);
@@ skipping 184 matching lines @@
 }
 
 SignalStrategy::State XmppSignalStrategy::GetState() const {
   return core_->GetState();
 }
 
 SignalStrategy::Error XmppSignalStrategy::GetError() const {
   return core_->GetError();
 }
 
-std::string XmppSignalStrategy::GetLocalJid() const {
-  return core_->GetLocalJid();
+const SignalingAddress& XmppSignalStrategy::GetLocalAddress() const {
+  return core_->GetLocalAddress();
 }
 
 void XmppSignalStrategy::AddListener(Listener* listener) {
   core_->AddListener(listener);
 }
 
 void XmppSignalStrategy::RemoveListener(Listener* listener) {
   core_->RemoveListener(listener);
 }
 bool XmppSignalStrategy::SendStanza(std::unique_ptr<buzz::XmlElement> stanza) {
   return core_->SendStanza(std::move(stanza));
 }
 
 std::string XmppSignalStrategy::GetNextId() {
   return base::Uint64ToString(base::RandUint64());
 }
 
 void XmppSignalStrategy::SetAuthInfo(const std::string& username,
                                      const std::string& auth_token) {
   core_->SetAuthInfo(username, auth_token);
 }
 
 }  // namespace remoting