Remove dependency on XMPP implementation in WebRTC

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 <vector>
+
 #include "base/bind.h"
 #include "base/location.h"
 #include "base/logging.h"
+#include "base/observer_list.h"
+#include "base/rand_util.h"
 #include "base/single_thread_task_runner.h"
-#include "base/strings/string_util.h"
+#include "base/strings/string_number_conversions.h"
 #include "base/thread_task_runner_handle.h"
-#include "jingle/glue/chrome_async_socket.h"
-#include "jingle/glue/task_pump.h"
-#include "jingle/glue/xmpp_client_socket_factory.h"
-#include "jingle/notifier/base/gaia_constants.h"
-#include "jingle/notifier/base/gaia_token_pre_xmpp_auth.h"
+#include "base/threading/thread_checker.h"
+#include "base/time/time.h"
+#include "base/timer/timer.h"
+#include "jingle/glue/proxy_resolving_client_socket.h"
+#include "net/cert/cert_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 "third_party/webrtc/base/thread.h"
-#include "third_party/webrtc/libjingle/xmpp/prexmppauth.h"
-#include "third_party/webrtc/libjingle/xmpp/saslcookiemechanism.h"
+#include "remoting/base/buffered_socket_writer.h"
+#include "remoting/signaling/xmpp_login_handler.h"
+#include "remoting/signaling/xmpp_stream_parser.h"
+#include "third_party/webrtc/libjingle/xmllite/xmlelement.h"
 
-const char kDefaultResourceName[] = "chromoting";
-
-// Use 58 seconds keep-alive interval, in case routers terminate
+// Use 50 seconds keep-alive interval, in case routers terminate
 // connections that are idle for more than a minute.
 const int kKeepAliveIntervalSeconds = 50;
 
-// Read buffer size used by ChromeAsyncSocket for read and write buffers.
-//
-// TODO(sergeyu): Currently jingle::ChromeAsyncSocket fails Write() when the
-// write buffer is full and talk::XmppClient just ignores the error. As result
-// chunks of data sent to the server are dropped (and they may not be full XMPP
-// stanzas). The problem needs to be fixed either in XmppClient on
-// ChromeAsyncSocket (e.g. ChromeAsyncSocket could close the connection when
-// buffer is full).
-const size_t kReadBufferSize = 64 * 1024;
-const size_t kWriteBufferSize = 64 * 1024;
+const int kReadBufferSize = 4096;
 
 const int kDefaultXmppPort = 5222;
 const int kDefaultHttpsPort = 443;
 
 namespace remoting {
 
-XmppSignalStrategy::XmppServerConfig::XmppServerConfig() {}
-XmppSignalStrategy::XmppServerConfig::~XmppServerConfig() {}
+XmppSignalStrategy::XmppServerConfig::XmppServerConfig()
+    : port(kDefaultXmppPort), use_tls(true) {
+}
 
-XmppSignalStrategy::XmppSignalStrategy(
+XmppSignalStrategy::XmppServerConfig::~XmppServerConfig() {
+}
+
+class XmppSignalStrategy::Core : public XmppLoginHandler::Delegate {
+ public:
+  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;
+  void AddListener(Listener* listener);
+  void RemoveListener(Listener* listener);
+  bool SendStanza(scoped_ptr<buzz::XmlElement> stanza);
+
+  void SetAuthInfo(const std::string& username,
+                   const std::string& auth_token);
+
+  void VerifyNoListeners();
+
+ private:
+  void OnSocketConnected(int result);
+  void OnTlsConnected(int result);
+
+  void ReadSocket();
+  void OnReadResult(int result);
+  void HandleReadResult(int result);
+
+  // XmppLoginHandler::Delegate interface.
+  void SendMessage(const std::string& message) override;
+  void StartTls() override;
+  void OnHandshakeDone(const std::string& jid,
+                       scoped_ptr<XmppStreamParser> parser) override;
+  void OnLoginHandlerError(SignalStrategy::Error error) override;
+
+  // Event handlers for XmppStreamParser.
+  void OnStanza(const scoped_ptr<buzz::XmlElement> stanza);
+  void OnParserError();
+
+  void OnNetworkError(int error);
+
+  void SendKeepAlive();
+
+  net::ClientSocketFactory* socket_factory_;
+  scoped_refptr<net::URLRequestContextGetter> request_context_getter_;
+  XmppServerConfig xmpp_server_config_;
+
+  // Used by the |socket_|.
+  scoped_ptr<net::CertVerifier> cert_verifier_;
+  scoped_ptr<net::TransportSecurityState> transport_security_state_;
+
+  scoped_ptr<net::StreamSocket> socket_;
+  scoped_ptr<BufferedSocketWriter> writer_;
+  scoped_refptr<net::IOBuffer> read_buffer_;
+  bool read_pending_;
+  bool tls_pending_;
+
+  scoped_ptr<XmppLoginHandler> login_handler_;
+  scoped_ptr<XmppStreamParser> stream_parser_;
+  std::string jid_;
+
+  Error error_;
+
+  ObserverList<Listener, true> listeners_;
+
+  base::Timer keep_alive_timer_;
+
+  base::ThreadChecker thread_checker_;
+
+  DISALLOW_COPY_AND_ASSIGN(Core);
+};
+
+XmppSignalStrategy::Core::Core(
     net::ClientSocketFactory* socket_factory,
     const scoped_refptr<net::URLRequestContextGetter>& request_context_getter,
     const XmppSignalStrategy::XmppServerConfig& xmpp_server_config)
     : socket_factory_(socket_factory),
       request_context_getter_(request_context_getter),
-      resource_name_(kDefaultResourceName),
-      xmpp_client_(nullptr),
       xmpp_server_config_(xmpp_server_config),
-      state_(DISCONNECTED),
-      error_(OK) {
+      read_pending_(false),
+      tls_pending_(false),
+      error_(OK),
+      keep_alive_timer_(
+          FROM_HERE,
+          base::TimeDelta::FromSeconds(kKeepAliveIntervalSeconds),
+          base::Bind(&Core::SendKeepAlive, base::Unretained(this)),
+          true) {
 #if defined(NDEBUG)
+  // Non-secure connections are allowed only for debugging.
   CHECK(xmpp_server_config_.use_tls);
 #endif
-}
 
-XmppSignalStrategy::~XmppSignalStrategy() {
-  Disconnect();
-
-  // Destroying task runner will destroy XmppClient, but XmppClient may be on
-  // the stack and it doesn't handle this case properly, so we need to delay
-  // destruction.
-  base::ThreadTaskRunnerHandle::Get()->DeleteSoon(
-      FROM_HERE, task_runner_.release());
-}
-
-void XmppSignalStrategy::Connect() {
-  DCHECK(CalledOnValidThread());
-
-  // Disconnect first if we are currently connected.
-  Disconnect();
-
-  buzz::XmppClientSettings settings;
-  buzz::Jid login_jid(xmpp_server_config_.username);
-  settings.set_user(login_jid.node());
-  settings.set_host(login_jid.domain());
-  settings.set_resource(resource_name_);
-  settings.set_token_service("oauth2");
-  settings.set_auth_token(buzz::AUTH_MECHANISM_GOOGLE_TOKEN,
-                          xmpp_server_config_.auth_token);
-
-  int port = xmpp_server_config_.port;
+  // TODO(sergeyu): Support for direct connections without TLS is not
+  // implemented yet.
+  if (!xmpp_server_config_.use_tls)
+    NOTIMPLEMENTED();
 
   // Port 5222 may be blocked by firewall. talk.google.com allows connections on
   // port 443 which can be used instead of 5222. The webapp still requests to
   // use port 5222 for backwards compatibility with older versions of the host
   // that do not pass correct |use_fake_ssl_client_socket| value to
   // XmppClientSocketFactory (and so cannot connect to port 443). In case we are
   // connecting to talk.google.com try to use port 443 anyway.
   //
   // TODO(sergeyu): Once all hosts support connections on port 443
   // the webapp needs to be updated to request port 443 and these 2 lines can be
   // removed. crbug.com/443384
-  if (xmpp_server_config_.host == "talk.google.com" && port == kDefaultXmppPort)
-    port = kDefaultHttpsPort;
-
-  settings.set_server(
-      rtc::SocketAddress(xmpp_server_config_.host, port));
-  settings.set_use_tls(
-      xmpp_server_config_.use_tls ? buzz::TLS_ENABLED : buzz::TLS_DISABLED);
-
-  // Enable fake SSL handshake when connecting over HTTPS port.
-  bool use_fake_ssl_client_socket = (port == kDefaultHttpsPort);
-
-  scoped_ptr<jingle_glue::XmppClientSocketFactory> xmpp_socket_factory(
-      new jingle_glue::XmppClientSocketFactory(socket_factory_,
-                                               net::SSLConfig(),
-                                               request_context_getter_,
-                                               use_fake_ssl_client_socket));
-  buzz::AsyncSocket* socket = new jingle_glue::ChromeAsyncSocket(
-      xmpp_socket_factory.release(), kReadBufferSize, kWriteBufferSize);
-
-  task_runner_.reset(new jingle_glue::TaskPump());
-  xmpp_client_ = new buzz::XmppClient(task_runner_.get());
-  xmpp_client_->Connect(
-      settings, std::string(), socket, CreatePreXmppAuth(settings));
-  xmpp_client_->SignalStateChange
-      .connect(this, &XmppSignalStrategy::OnConnectionStateChanged);
-  xmpp_client_->engine()->AddStanzaHandler(this, buzz::XmppEngine::HL_TYPE);
-  xmpp_client_->Start();
-
-  SetState(CONNECTING);
+  if (xmpp_server_config_.host == "talk.google.com" &&
+      xmpp_server_config_.port == kDefaultXmppPort) {
+    xmpp_server_config_.port = kDefaultHttpsPort;
+  }
+}
+
+XmppSignalStrategy::Core::~Core() {
+  Disconnect();
+}
+
+void XmppSignalStrategy::Core::Connect() {
+  DCHECK(thread_checker_.CalledOnValidThread());
+
+  // Disconnect first if we are currently connected.
+  Disconnect();
+
+  error_ = OK;
+
+  FOR_EACH_OBSERVER(Listener, listeners_,
+                    OnSignalStrategyStateChange(CONNECTING));
+
+  socket_.reset(new jingle_glue::ProxyResolvingClientSocket(
+      socket_factory_, request_context_getter_, net::SSLConfig(),
+      net::HostPortPair(xmpp_server_config_.host, xmpp_server_config_.port)));
+
+  int result = socket_->Connect(base::Bind(
+      &Core::OnSocketConnected, base::Unretained(this)));
+  if (result != net::ERR_IO_PENDING)
+    OnSocketConnected(result);
+}
+
+void XmppSignalStrategy::Core::Disconnect() {
+  DCHECK(thread_checker_.CalledOnValidThread());
+
+  if (socket_) {
+    login_handler_.reset();
+    stream_parser_.reset();
+    writer_.reset();
+    socket_.reset();
+
+    FOR_EACH_OBSERVER(Listener, listeners_,
+                      OnSignalStrategyStateChange(DISCONNECTED));
+  }
+}
+
+SignalStrategy::State XmppSignalStrategy::Core::GetState() const {
+  DCHECK(thread_checker_.CalledOnValidThread());
+
+  if (stream_parser_) {
+    DCHECK(socket_);
+    return CONNECTED;
+  } else if (socket_) {
+    return CONNECTING;
+  } else {
+    return DISCONNECTED;
+  }
+}
+
+SignalStrategy::Error XmppSignalStrategy::Core::GetError() const {
+  DCHECK(thread_checker_.CalledOnValidThread());
+  return error_;
+}
+
+std::string XmppSignalStrategy::Core::GetLocalJid() const {
+  DCHECK(thread_checker_.CalledOnValidThread());
+  return jid_;
+}
+
+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);
+}
+
+bool XmppSignalStrategy::Core::SendStanza(scoped_ptr<buzz::XmlElement> stanza) {
+  DCHECK(thread_checker_.CalledOnValidThread());
+
+  if (!stream_parser_) {
+    VLOG(0) << "Dropping signalling message because XMPP "
+               "connection has been terminated.";
+    return false;
+  }
+
+  SendMessage(stanza->Str());
+  return true;
+}
+
+void XmppSignalStrategy::Core::SetAuthInfo(const std::string& username,
+                                           const std::string& auth_token) {
+  DCHECK(thread_checker_.CalledOnValidThread());
+  xmpp_server_config_.username = username;
+  xmpp_server_config_.auth_token = auth_token;
+}
+
+void XmppSignalStrategy::Core::SendMessage(const std::string& message) {
+  DCHECK(thread_checker_.CalledOnValidThread());
+  scoped_refptr<net::IOBufferWithSize> buffer =
+      new net::IOBufferWithSize(message.size());
+  memcpy(buffer->data(), message.data(), message.size());
+  writer_->Write(buffer, base::Closure());
+}
+
+void XmppSignalStrategy::Core::StartTls() {
+  DCHECK(thread_checker_.CalledOnValidThread());
+  DCHECK(login_handler_);
+
+  // Reset the writer so we don't try to write to the raw socket anymore.
+  DCHECK_EQ(writer_->GetBufferSize(), 0);
+  writer_.reset();
+
+  DCHECK(!read_pending_);
+
+  scoped_ptr<net::ClientSocketHandle> socket_handle(
+      new net::ClientSocketHandle());
+  socket_handle->SetSocket(socket_.Pass());
+
+  cert_verifier_.reset(net::CertVerifier::CreateDefault());
+  transport_security_state_.reset(new net::TransportSecurityState());
+  net::SSLClientSocketContext context;
+  context.cert_verifier = cert_verifier_.get();
+  context.transport_security_state = transport_security_state_.get();
+
+  socket_ = socket_factory_->CreateSSLClientSocket(
+      socket_handle.Pass(),
+      net::HostPortPair(xmpp_server_config_.host, kDefaultHttpsPort),
+      net::SSLConfig(), context);
+
+  tls_pending_ = true;
+  int result = socket_->Connect(
+      base::Bind(&Core::OnTlsConnected, base::Unretained(this)));
+  if (result != net::ERR_IO_PENDING)
+    OnTlsConnected(result);
+}
+
+void XmppSignalStrategy::Core::OnHandshakeDone(
+    const std::string& jid,
+    scoped_ptr<XmppStreamParser> parser) {
+  DCHECK(thread_checker_.CalledOnValidThread());
+
+  jid_ = jid;
+  stream_parser_ = parser.Pass();
+  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_EACH_OBSERVER(Listener, listeners_,
+                    OnSignalStrategyStateChange(CONNECTED));
+}
+
+void XmppSignalStrategy::Core::OnLoginHandlerError(
+    SignalStrategy::Error error) {
+  DCHECK(thread_checker_.CalledOnValidThread());
+
+  error_ = error;
+  Disconnect();
+}
+
+void XmppSignalStrategy::Core::OnStanza(
+    const scoped_ptr<buzz::XmlElement> stanza) {
+  DCHECK(thread_checker_.CalledOnValidThread());
+
+  ObserverListBase<Listener>::Iterator it(&listeners_);
+  for (Listener* listener = it.GetNext(); listener; listener = it.GetNext()) {
+    if (listener->OnSignalStrategyIncomingStanza(stanza.get()))
+      return;
+  }
+}
+
+void XmppSignalStrategy::Core::OnParserError() {
+  DCHECK(thread_checker_.CalledOnValidThread());
+
+  error_ = NETWORK_ERROR;
+  Disconnect();
+}
+
+void XmppSignalStrategy::Core::OnSocketConnected(int result) {
+  DCHECK(thread_checker_.CalledOnValidThread());
+
+  if (result != net::OK) {
+    OnNetworkError(result);
+    return;
+  }
+
+  writer_.reset(new BufferedSocketWriter());
+  writer_->Init(socket_.get(), base::Bind(&Core::OnNetworkError,
+                                          base::Unretained(this)));
+
+  XmppLoginHandler::TlsMode tls_mode;
+  if (xmpp_server_config_.use_tls) {
+    tls_mode = (xmpp_server_config_.port == kDefaultXmppPort)
+                   ? XmppLoginHandler::TlsMode::WITH_HANDSHAKE
+                   : XmppLoginHandler::TlsMode::WITHOUT_HANDSHAKE;
+  } else {
+    tls_mode = XmppLoginHandler::TlsMode::NO_TLS;
+  }
+
+  // The server name is passed as to attribute in the <stream>. When connecting
+  // to talk.google.com it affects the certificate the server will use for TLS:
+  // talk.google.com uses gmail certificate when specified server is gmail.com
+  // or googlemail.com and google.com cert otherwise. In the same time it
+  // doesn't accept talk.google.com as target server. Here we use google.com
+  // server name when authenticating to talk.google.com. This ensures that the
+  // server will use google.com cert which will be accepted by the TLS
+  // implementation in Chrome (TLS API doesn't allow specifying domain other
+  // than the one that was passed to connect()).
+  std::string server = xmpp_server_config_.host;
+  if (server == "talk.google.com")
+    server = "google.com";
+
+  login_handler_.reset(
+      new XmppLoginHandler(server, xmpp_server_config_.username,
+                           xmpp_server_config_.auth_token, tls_mode, this));
+  login_handler_->Start();
+
+  ReadSocket();
+}
+
+void XmppSignalStrategy::Core::OnTlsConnected(int result) {
+  DCHECK(thread_checker_.CalledOnValidThread());
+  DCHECK(tls_pending_);
+  tls_pending_ = false;
+
+  if (result != net::OK) {
+    OnNetworkError(result);
+    return;
+  }
+
+  writer_.reset(new BufferedSocketWriter());
+  writer_->Init(socket_.get(), base::Bind(&Core::OnNetworkError,
+                                          base::Unretained(this)));
+
+  login_handler_->OnTlsStarted();
+
+  ReadSocket();
+}
+
+void XmppSignalStrategy::Core::ReadSocket() {
+  DCHECK(thread_checker_.CalledOnValidThread());
+
+  while (socket_ && !read_pending_ && !tls_pending_) {
+    read_buffer_ = new net::IOBuffer(kReadBufferSize);
+    int result = socket_->Read(
+        read_buffer_.get(), kReadBufferSize,
+        base::Bind(&Core::OnReadResult, base::Unretained(this)));
+    HandleReadResult(result);
+  }
+}
+
+void XmppSignalStrategy::Core::OnReadResult(int result) {
+  DCHECK(thread_checker_.CalledOnValidThread());
+  DCHECK(read_pending_);
+  read_pending_ = false;
+  HandleReadResult(result);
+  ReadSocket();
+}
+
+void XmppSignalStrategy::Core::HandleReadResult(int result) {
+  DCHECK(thread_checker_.CalledOnValidThread());
+
+  if (result == net::ERR_IO_PENDING) {
+    read_pending_ = true;
+    return;
+  }
+
+  if (result < 0) {
+    OnNetworkError(result);
+    return;
+  }
+
+  if (result == 0) {
+    // Connection was closed by the server.
+    error_ = OK;
+    Disconnect();
+    return;
+  }
+
+  if (stream_parser_) {
+    stream_parser_->AppendData(std::string(read_buffer_->data(), result));
+  } else {
+    login_handler_->OnDataReceived(std::string(read_buffer_->data(), result));
+  }
+}
+
+void XmppSignalStrategy::Core::OnNetworkError(int error) {
+  DCHECK(thread_checker_.CalledOnValidThread());
+
+  LOG(ERROR) << "XMPP socket error " << error;
+  error_ = NETWORK_ERROR;
+  Disconnect();
+}
+
+void XmppSignalStrategy::Core::SendKeepAlive() {
+  DCHECK(thread_checker_.CalledOnValidThread());
+
+  if (GetState() == CONNECTED)
+    SendMessage(" ");
+}
+
+XmppSignalStrategy::XmppSignalStrategy(
+    net::ClientSocketFactory* socket_factory,
+    const scoped_refptr<net::URLRequestContextGetter>& request_context_getter,
+    const XmppServerConfig& xmpp_server_config)
+    : core_(new Core(socket_factory,
+                     request_context_getter,
+                     xmpp_server_config)) {
+}
+
+XmppSignalStrategy::~XmppSignalStrategy() {
+  // All listeners should be removed at this point, so it's safe to detach
+  // |core_|.
+  base::ThreadTaskRunnerHandle::Get()->DeleteSoon(FROM_HERE, core_.release());
+}
+
+void XmppSignalStrategy::Connect() {
+  core_->Connect();
 }
 
 void XmppSignalStrategy::Disconnect() {
-  DCHECK(CalledOnValidThread());
-
-  if (xmpp_client_) {
-    xmpp_client_->engine()->RemoveStanzaHandler(this);
-
-    xmpp_client_->Disconnect();
-
-    // |xmpp_client_| should be set to nullptr in OnConnectionStateChanged()
-    // in response to Disconnect() call above.
-    DCHECK(xmpp_client_ == nullptr);
-  }
+  core_->Disconnect();
 }
 
 SignalStrategy::State XmppSignalStrategy::GetState() const {
-  DCHECK(CalledOnValidThread());
-  return state_;
+  return core_->GetState();
 }
 
 SignalStrategy::Error XmppSignalStrategy::GetError() const {
-  DCHECK(CalledOnValidThread());
-  return error_;
+  return core_->GetError();
 }
 
 std::string XmppSignalStrategy::GetLocalJid() const {
-  DCHECK(CalledOnValidThread());
-  return xmpp_client_->jid().Str();
+  return core_->GetLocalJid();
 }
 
 void XmppSignalStrategy::AddListener(Listener* listener) {
-  DCHECK(CalledOnValidThread());
-  listeners_.AddObserver(listener);
+  core_->AddListener(listener);
 }
 
 void XmppSignalStrategy::RemoveListener(Listener* listener) {
-  DCHECK(CalledOnValidThread());
-  listeners_.RemoveObserver(listener);
-}
-
+  core_->RemoveListener(listener);
+}
 bool XmppSignalStrategy::SendStanza(scoped_ptr<buzz::XmlElement> stanza) {
-  DCHECK(CalledOnValidThread());
-  if (!xmpp_client_) {
-    VLOG(0) << "Dropping signalling message because XMPP "
-        "connection has been terminated.";
-    return false;
-  }
-
-  buzz::XmppReturnStatus status = xmpp_client_->SendStanza(stanza.release());
-  return status == buzz::XMPP_RETURN_OK || status == buzz::XMPP_RETURN_PENDING;
+  return core_->SendStanza(stanza.Pass());
 }
 
 std::string XmppSignalStrategy::GetNextId() {
-  DCHECK(CalledOnValidThread());
-  if (!xmpp_client_) {
-    // If the connection has been terminated then it doesn't matter
-    // what Id we return.
-    return std::string();
-  }
-  return xmpp_client_->NextId();
-}
-
-bool XmppSignalStrategy::HandleStanza(const buzz::XmlElement* stanza) {
-  DCHECK(CalledOnValidThread());
-  ObserverListBase<Listener>::Iterator it(&listeners_);
-  Listener* listener;
-  while ((listener = it.GetNext()) != nullptr) {
-    if (listener->OnSignalStrategyIncomingStanza(stanza))
-      return true;
-  }
-  return false;
+  return base::Uint64ToString(base::RandUint64());
 }
 
 void XmppSignalStrategy::SetAuthInfo(const std::string& username,
                                      const std::string& auth_token) {
-  DCHECK(CalledOnValidThread());
-  xmpp_server_config_.username = username;
-  xmpp_server_config_.auth_token = auth_token;
-}
-
-void XmppSignalStrategy::SetResourceName(const std::string &resource_name) {
-  DCHECK(CalledOnValidThread());
-  resource_name_ = resource_name;
-}
-
-void XmppSignalStrategy::OnConnectionStateChanged(
-    buzz::XmppEngine::State state) {
-  DCHECK(CalledOnValidThread());
-
-  if (state == buzz::XmppEngine::STATE_OPEN) {
-    keep_alive_timer_.Start(
-        FROM_HERE, base::TimeDelta::FromSeconds(kKeepAliveIntervalSeconds),
-        this, &XmppSignalStrategy::SendKeepAlive);
-    SetState(CONNECTED);
-  } else if (state == buzz::XmppEngine::STATE_CLOSED) {
-    // Make sure we dump errors to the log.
-    int subcode;
-    buzz::XmppEngine::Error error = xmpp_client_->GetError(&subcode);
-    VLOG(0) << "XMPP connection was closed: error=" << error
-            << ", subcode=" << subcode;
-
-    keep_alive_timer_.Stop();
-
-    // Client is destroyed by the TaskRunner after the client is
-    // closed. Reset the pointer so we don't try to use it later.
-    xmpp_client_ = nullptr;
-
-    switch (error) {
-      case buzz::XmppEngine::ERROR_UNAUTHORIZED:
-      case buzz::XmppEngine::ERROR_AUTH:
-      case buzz::XmppEngine::ERROR_MISSING_USERNAME:
-        error_ = AUTHENTICATION_FAILED;
-        break;
-
-      default:
-        error_ = NETWORK_ERROR;
-    }
-
-    SetState(DISCONNECTED);
-  }
-}
-
-void XmppSignalStrategy::SetState(State new_state) {
-  if (state_ != new_state) {
-    state_ = new_state;
-    FOR_EACH_OBSERVER(Listener, listeners_,
-                      OnSignalStrategyStateChange(new_state));
-  }
-}
-
-void XmppSignalStrategy::SendKeepAlive() {
-  xmpp_client_->SendRaw(" ");
-}
-
-// static
-buzz::PreXmppAuth* XmppSignalStrategy::CreatePreXmppAuth(
-    const buzz::XmppClientSettings& settings) {
-  buzz::Jid jid(settings.user(), settings.host(), buzz::STR_EMPTY);
-  return new notifier::GaiaTokenPreXmppAuth(
-      jid.Str(), settings.auth_token(), settings.token_service(), "X-OAUTH2");
+  core_->SetAuthInfo(username, auth_token);
 }
 
 }  // namespace remoting