Enables delegating signal strategy for It2Me Host.

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 123 matching lines @@
   TlsState tls_state_ = TlsState::NOT_REQUESTED;
 
   std::unique_ptr<XmppLoginHandler> login_handler_;
   std::unique_ptr<XmppStreamParser> stream_parser_;
   std::string jid_;
 
   Error error_ = OK;
 
   base::ObserverList<Listener, true> listeners_;
 
-  base::Timer keep_alive_timer_;
+  base::RepeatingTimer 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),
-      xmpp_server_config_(xmpp_server_config),
-      keep_alive_timer_(
-          FROM_HERE,
-          base::TimeDelta::FromSeconds(kKeepAliveIntervalSeconds),
-          base::Bind(&Core::SendKeepAlive, base::Unretained(this)),
-          true) {
+      xmpp_server_config_(xmpp_server_config) {
 #if defined(NDEBUG)
   // Non-secure connections are allowed only for debugging.
   CHECK(xmpp_server_config_.use_tls);
 #endif
+  thread_checker_.DetachFromThread();
 }
 
 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)));
+
+  keep_alive_timer_.Start(
+      FROM_HERE, base::TimeDelta::FromSeconds(kKeepAliveIntervalSeconds),
+      base::Bind(&Core::SendKeepAlive, 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();
@@ skipping 350 matching lines @@
 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