Refactor SignalStrategy so that it can be reused for multiple connections.

remoting/protocol/jingle_session_manager.cc

 // Copyright (c) 2011 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 <limits>
 
 #include "base/base64.h"
 #include "base/bind.h"
@@ skipping 15 matching lines @@
 using buzz::XmlElement;
 
 namespace remoting {
 namespace protocol {
 
 JingleSessionManager::JingleSessionManager(
     base::MessageLoopProxy* message_loop)
     : message_loop_(message_loop),
       signal_strategy_(NULL),
       allow_nat_traversal_(false),
+      ready_(false),
       http_port_allocator_(NULL),
       closed_(false),
       ALLOW_THIS_IN_INITIALIZER_LIST(task_factory_(this)) {
 }
 
 JingleSessionManager::~JingleSessionManager() {
   // Session manager can be destroyed only after all sessions are destroyed.
   DCHECK(sessions_.empty());
   Close();
 }
 
 void JingleSessionManager::Init(
-    const std::string& local_jid,
     SignalStrategy* signal_strategy,
-    Listener* listener,
+    SessionManager::Listener* listener,
     bool allow_nat_traversal) {
   DCHECK(CalledOnValidThread());
 
   DCHECK(signal_strategy);
   DCHECK(listener);
 
-  local_jid_ = local_jid;
   signal_strategy_ = signal_strategy;
   listener_ = listener;
   allow_nat_traversal_ = allow_nat_traversal;
 
+  signal_strategy_->AddListener(this);
+
   if (!network_manager_.get()) {
     VLOG(1) << "Creating talk_base::NetworkManager.";
     network_manager_.reset(new talk_base::BasicNetworkManager());
   }
   if (!socket_factory_.get()) {
     VLOG(1) << "Creating talk_base::BasicPacketSocketFactory.";
     socket_factory_.reset(new talk_base::BasicPacketSocketFactory(
         talk_base::Thread::Current()));
   }
 
@@ skipping 18 matching lines @@
   port_allocator_->set_flags(port_allocator_flags);
 
   // Initialize |cricket_session_manager_|.
   cricket_session_manager_.reset(
       new cricket::SessionManager(port_allocator_.get()));
   cricket_session_manager_->AddClient(kChromotingXmlNamespace, this);
 
   jingle_signaling_connector_.reset(new JingleSignalingConnector(
       signal_strategy_, cricket_session_manager_.get()));
 
-  // If NAT traversal is enabled then we need to request STUN/Relay info.
-  if (allow_nat_traversal) {
-    jingle_info_request_.reset(new JingleInfoRequest(signal_strategy_));
-    jingle_info_request_->Send(base::Bind(
-        &JingleSessionManager::OnJingleInfo, base::Unretained(this)));
-  } else {
-    listener_->OnSessionManagerInitialized();
-  }
+  OnSignalStrategyStateChange(signal_strategy_->GetState());
 }
 
 void JingleSessionManager::Close() {
   DCHECK(CalledOnValidThread());
 
   if (!closed_) {
     jingle_info_request_.reset();
     cricket_session_manager_->RemoveClient(kChromotingXmlNamespace);
     jingle_signaling_connector_.reset();
+    signal_strategy_->RemoveListener(this);
     closed_ = true;
   }
 }
 
 void JingleSessionManager::set_authenticator_factory(
     AuthenticatorFactory* authenticator_factory) {
   DCHECK(CalledOnValidThread());
   authenticator_factory_.reset(authenticator_factory);
 }
 
 Session* JingleSessionManager::Connect(
     const std::string& host_jid,
     Authenticator* authenticator,
     CandidateSessionConfig* candidate_config,
     const Session::StateChangeCallback& state_change_callback) {
   DCHECK(CalledOnValidThread());
 
   cricket::Session* cricket_session = cricket_session_manager_->CreateSession(
-      local_jid_, kChromotingXmlNamespace);
+      signal_strategy_->GetLocalJid(), kChromotingXmlNamespace);
   cricket_session->set_remote_name(host_jid);
 
   JingleSession* jingle_session =
       new JingleSession(this, cricket_session, authenticator);
   jingle_session->set_candidate_config(candidate_config);
   jingle_session->SetStateChangeCallback(state_change_callback);
   sessions_.push_back(jingle_session);
 
   jingle_session->SendSessionInitiate();
 
@@ skipping 19 matching lines @@
 
   std::list<JingleSession*>::iterator it;
   for (it = sessions_.begin(); it != sessions_.end(); ++it) {
     if ((*it)->HasSession(cricket_session)) {
       (*it)->ReleaseSession();
       return;
     }
   }
 }
 
+void JingleSessionManager::OnSignalStrategyStateChange(
+    SignalStrategy::State state) {
+  if (state == SignalStrategy::CONNECTED) {
+    // If NAT traversal is enabled then we need to request STUN/Relay info.
+    if (allow_nat_traversal_) {
+      jingle_info_request_.reset(new JingleInfoRequest(signal_strategy_));
+      jingle_info_request_->Send(base::Bind(
+          &JingleSessionManager::OnJingleInfo, base::Unretained(this)));
+    } else if (!ready_) {
+      ready_ = true;
+      listener_->OnSessionManagerReady();
+    }
+  }
+}
+
 SessionManager::IncomingSessionResponse JingleSessionManager::AcceptConnection(
     JingleSession* jingle_session) {
   DCHECK(CalledOnValidThread());
 
   // Reject connection if we are closed.
   if (closed_)
     return SessionManager::DECLINE;
 
   IncomingSessionResponse response = SessionManager::DECLINE;
   listener_->OnIncomingSession(jingle_session, &response);
@@ skipping 33 matching lines @@
     VLOG(1) << "Configuring with relay token: " << token
             << ", relays: " << JoinString(relay_hosts, ';')
             << ", stun: " << stun_servers;
     http_port_allocator_->SetRelayToken(token);
     http_port_allocator_->SetStunHosts(stun_hosts);
     http_port_allocator_->SetRelayHosts(relay_hosts);
   } else {
     LOG(WARNING) << "Jingle info found but no port allocator.";
   }
 
-  listener_->OnSessionManagerInitialized();
+  if (!ready_) {
+    ready_ = true;
+    listener_->OnSessionManagerReady();
+  }
 }
 
 // Parse content description generated by WriteContent().
 bool JingleSessionManager::ParseContent(
     cricket::SignalingProtocol protocol,
     const XmlElement* element,
     const cricket::ContentDescription** content,
     cricket::ParseError* error) {
   *content = ContentDescription::ParseXml(element);
   return *content != NULL;
 }
 
 bool JingleSessionManager::WriteContent(
     cricket::SignalingProtocol protocol,
     const cricket::ContentDescription* content,
     XmlElement** elem,
     cricket::WriteError* error) {
   const ContentDescription* desc =
       static_cast<const ContentDescription*>(content);
 
   *elem = desc->ToXml();
   return true;
 }
 
 }  // namespace protocol
 }  // namespace remoting