Minor cleanups in JingleSession and JingleSessionManager.

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/message_loop.h"
 #include "base/string_util.h"
 #include "base/task.h"
 #include "remoting/base/constants.h"
 #include "remoting/jingle_glue/http_port_allocator.h"
 #include "remoting/jingle_glue/jingle_info_request.h"
 #include "remoting/jingle_glue/jingle_signaling_connector.h"
 #include "remoting/jingle_glue/signal_strategy.h"
 #include "third_party/libjingle/source/talk/base/basicpacketsocketfactory.h"
 #include "third_party/libjingle/source/talk/p2p/base/sessionmanager.h"
 #include "third_party/libjingle/source/talk/p2p/base/transport.h"
 #include "third_party/libjingle/source/talk/p2p/base/constants.h"
 #include "third_party/libjingle/source/talk/p2p/base/transport.h"
 #include "third_party/libjingle/source/talk/xmllite/xmlelement.h"
 
 using buzz::XmlElement;
 
 namespace remoting {
 namespace protocol {
 
+// static
+JingleSessionManager* JingleSessionManager::CreateNotSandboxed() {
+  return new JingleSessionManager(NULL, NULL, NULL);
+}
+
+// static
+JingleSessionManager* JingleSessionManager::CreateSandboxed(
+    talk_base::NetworkManager* network_manager,
+    talk_base::PacketSocketFactory* socket_factory,
+    PortAllocatorSessionFactory* port_allocator_session_factory) {
+  return new JingleSessionManager(network_manager, socket_factory,
+                                  port_allocator_session_factory);
+}
+
 JingleSessionManager::JingleSessionManager(
     talk_base::NetworkManager* network_manager,
     talk_base::PacketSocketFactory* socket_factory,
     PortAllocatorSessionFactory* port_allocator_session_factory)
     : network_manager_(network_manager),
       socket_factory_(socket_factory),
       port_allocator_session_factory_(port_allocator_session_factory),
       signal_strategy_(NULL),
       enable_nat_traversing_(false),
       allow_local_ips_(false),
       http_port_allocator_(NULL),
       closed_(false),
       ALLOW_THIS_IN_INITIALIZER_LIST(task_factory_(this)) {
 }
 
 JingleSessionManager::~JingleSessionManager() {
-  DCHECK(closed_);
+  Close();
 }
 
 void JingleSessionManager::Init(
     const std::string& local_jid,
     SignalStrategy* signal_strategy,
     IncomingSessionCallback* incoming_session_callback,
     crypto::RSAPrivateKey* private_key,
     scoped_refptr<net::X509Certificate> certificate) {
   DCHECK(CalledOnValidThread());
 
@@ skipping 64 matching lines @@
     CandidateSessionConfig* candidate_config,
     Session::StateChangeCallback* state_change_callback) {
   DCHECK(CalledOnValidThread());
 
   // Can be called from any thread.
   JingleSession* jingle_session =
       JingleSession::CreateClientSession(this, host_public_key);
   jingle_session->set_candidate_config(candidate_config);
   jingle_session->set_receiver_token(receiver_token);
 
-  // TODO(sergeyu): Does this need to be asynchronous?
-  MessageLoop::current()->PostTask(FROM_HERE, task_factory_.NewRunnableMethod(
-      &JingleSessionManager::DoConnect, jingle_session, host_jid,
-      host_public_key, receiver_token, state_change_callback));
-  return jingle_session;
-}
-
-void JingleSessionManager::DoConnect(
-    JingleSession* jingle_session,
-    const std::string& host_jid,
-    const std::string& host_public_key,
-    const std::string& receiver_token,
-    Session::StateChangeCallback* state_change_callback) {
-  DCHECK(CalledOnValidThread());
-
   cricket::Session* cricket_session = cricket_session_manager_->CreateSession(
       local_jid_, kChromotingXmlNamespace);
 
   // Initialize connection object before we send initiate stanza.
   jingle_session->SetStateChangeCallback(state_change_callback);
   jingle_session->Init(cricket_session);
   sessions_.push_back(jingle_session);
 
   cricket_session->Initiate(host_jid, CreateClientSessionDescription(
       jingle_session->candidate_config()->Clone(), receiver_token,
       jingle_session->GetEncryptedMasterKey()));
+
+  return jingle_session;
 }
 
 void JingleSessionManager::OnSessionCreate(
     cricket::Session* cricket_session, bool incoming) {
   DCHECK(CalledOnValidThread());
 
   // Allow local connections if neccessary.
   cricket_session->set_allow_local_ips(allow_local_ips_);
 
   // If this is an outcoming session the session object is already created.
@@ skipping 88 matching lines @@
   cricket_session_manager_->DestroySession(cricket_session);
   sessions_.erase(it);
 }
 
 void JingleSessionManager::OnJingleInfo(
     const std::string& token,
     const std::vector<std::string>& relay_hosts,
     const std::vector<talk_base::SocketAddress>& stun_hosts) {
   DCHECK(CalledOnValidThread());
 
-  if (port_allocator_.get()) {
+  if (http_port_allocator_) {
     // TODO(ajwong): Avoid string processing if log-level is low.
     std::string stun_servers;
     for (size_t i = 0; i < stun_hosts.size(); ++i) {
       stun_servers += stun_hosts[i].ToString() + "; ";
     }
     LOG(INFO) << "Configuring with relay token: " << token
               << ", relays: " << JoinString(relay_hosts, ';')
               << ", stun: " << stun_servers;
     http_port_allocator_->SetRelayToken(token);
     http_port_allocator_->SetStunHosts(stun_hosts);
@@ skipping 55 matching lines @@
     scoped_refptr<net::X509Certificate> certificate) {
   cricket::SessionDescription* desc = new cricket::SessionDescription();
   desc->AddContent(
       JingleSession::kChromotingContentName, kChromotingXmlNamespace,
       new ContentDescription(config, "", "", certificate));
   return desc;
 }
 
 }  // namespace protocol
 }  // namespace remoting