Move PseudoTCP and channel auth out of LibjingleTransportFactory.

remoting/protocol/jingle_session.cc

 // Copyright (c) 2012 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.h"
 
 #include "base/bind.h"
 #include "base/rand_util.h"
 #include "base/single_thread_task_runner.h"
 #include "base/stl_util.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/thread_task_runner_handle.h"
 #include "base/time/time.h"
 #include "remoting/base/constants.h"
 #include "remoting/protocol/authenticator.h"
 #include "remoting/protocol/channel_authenticator.h"
 #include "remoting/protocol/channel_multiplexer.h"
 #include "remoting/protocol/content_description.h"
 #include "remoting/protocol/jingle_messages.h"
 #include "remoting/protocol/jingle_session_manager.h"
+#include "remoting/protocol/pseudotcp_channel_factory.h"
+#include "remoting/protocol/secure_channel_factory.h"
 #include "remoting/protocol/session_config.h"
+#include "remoting/protocol/stream_channel_factory.h"
 #include "remoting/signaling/iq_sender.h"
 #include "third_party/libjingle/source/talk/p2p/base/candidate.h"
 #include "third_party/webrtc/libjingle/xmllite/xmlelement.h"
 
 using buzz::XmlElement;
 
 namespace remoting {
 namespace protocol {
 
 namespace {
@@ skipping 42 matching lines @@
       config_is_set_(false),
       weak_factory_(this) {
 }
 
 JingleSession::~JingleSession() {
   channel_multiplexer_.reset();
   STLDeleteContainerPointers(pending_requests_.begin(),
                              pending_requests_.end());
   STLDeleteContainerPointers(transport_info_requests_.begin(),
                              transport_info_requests_.end());
-  STLDeleteContainerPairSecondPointers(channels_.begin(), channels_.end());
+  DCHECK(channels_.empty());
   session_manager_->SessionDestroyed(this);
 }
 
 void JingleSession::SetEventHandler(Session::EventHandler* event_handler) {
   DCHECK(CalledOnValidThread());
   DCHECK(event_handler);
   event_handler_ = event_handler;
 }
 
 ErrorCode JingleSession::error() {
@@ skipping 85 matching lines @@
 
   message.description.reset(
       new ContentDescription(CandidateSessionConfig::CreateFrom(config_),
                              auth_message.Pass()));
   SendMessage(message);
 
   // Update state.
   SetState(CONNECTED);
 
   if (authenticator_->state() == Authenticator::ACCEPTED) {
-    SetState(AUTHENTICATED);
+    OnAuthenticated();
   } else {
     DCHECK_EQ(authenticator_->state(), Authenticator::WAITING_MESSAGE);
     if (authenticator_->started()) {
       SetState(AUTHENTICATING);
     }
   }
 }
 
 const std::string& JingleSession::jid() {
   DCHECK(CalledOnValidThread());
@@ skipping 10 matching lines @@
   return config_;
 }
 
 void JingleSession::set_config(const SessionConfig& config) {
   DCHECK(CalledOnValidThread());
   DCHECK(!config_is_set_);
   config_ = config;
   config_is_set_ = true;
 }
 
-ChannelFactory* JingleSession::GetTransportChannelFactory() {
+StreamChannelFactory* JingleSession::GetTransportChannelFactory() {
   DCHECK(CalledOnValidThread());
-  return this;
+  return secure_channel_factory_.get();
 }
 
-ChannelFactory* JingleSession::GetMultiplexedChannelFactory() {
+StreamChannelFactory* JingleSession::GetMultiplexedChannelFactory() {
   DCHECK(CalledOnValidThread());
-  if (!channel_multiplexer_.get())
-    channel_multiplexer_.reset(new ChannelMultiplexer(this, kMuxChannelName));
+  if (!channel_multiplexer_.get()) {
+    channel_multiplexer_.reset(
+        new ChannelMultiplexer(GetTransportChannelFactory(), kMuxChannelName));
+  }
   return channel_multiplexer_.get();
 }
 
 void JingleSession::Close() {
   DCHECK(CalledOnValidThread());
 
   CloseInternal(OK);
 }
 
 void JingleSession::AddPendingRemoteCandidates(Transport* channel,
                                                const std::string& name) {
   std::list<JingleMessage::NamedCandidate>::iterator it =
       pending_remote_candidates_.begin();
   while(it != pending_remote_candidates_.end()) {
     if (it->name == name) {
       channel->AddRemoteCandidate(it->candidate);
       it = pending_remote_candidates_.erase(it);
     } else {
       ++it;
     }
   }
 }
 
 void JingleSession::CreateChannel(const std::string& name,
                                   const ChannelCreatedCallback& callback) {
   DCHECK(!channels_[name]);
 
-  scoped_ptr<ChannelAuthenticator> channel_authenticator =
-      authenticator_->CreateChannelAuthenticator();
-  scoped_ptr<StreamTransport> channel =
-      session_manager_->transport_factory_->CreateStreamTransport();
-  channel->Initialize(name, this, channel_authenticator.Pass());
-  channel->Connect(callback);
+  scoped_ptr<Transport> channel =
+      session_manager_->transport_factory_->CreateTransport();
+  channel->Connect(name, this, callback);
   AddPendingRemoteCandidates(channel.get(), name);
   channels_[name] = channel.release();
 }
 
 void JingleSession::CancelChannelCreation(const std::string& name) {
   ChannelsMap::iterator it = channels_.find(name);
-  if (it != channels_.end() && !it->second->is_connected()) {
+  if (it != channels_.end()) {
+    DCHECK(!it->second->is_connected());

[Wez, 2014/09/10 22:19:42]

Is there any possibility of a race condition here, between cancel requests and
us being notified that the underlying channel is connected?

[Sergey Ulanov, 2014/09/10 22:49:31]

I don't think so. Both events happen on the same thread.

     delete it->second;
     DCHECK(!channels_[name]);
   }
 }
 
 void JingleSession::OnTransportCandidate(Transport* transport,
                                          const cricket::Candidate& candidate) {
   pending_candidates_.push_back(JingleMessage::NamedCandidate(
       transport->name(), candidate));
 
@@ skipping 311 matching lines @@
     base::Bind(&JingleSession::ContinueAuthenticationStep,
                weak_factory_.GetWeakPtr()));
 
   if (authenticator_->started()) {
     SetState(AUTHENTICATING);
   }
 }
 
 void JingleSession::ContinueAuthenticationStep() {
   if (authenticator_->state() == Authenticator::ACCEPTED) {
-    SetState(AUTHENTICATED);
+    OnAuthenticated();
   } else if (authenticator_->state() == Authenticator::REJECTED) {
     CloseInternal(AuthRejectionReasonToErrorCode(
         authenticator_->rejection_reason()));
   }
 }
 
+void JingleSession::OnAuthenticated() {
+  pseudotcp_channel_factory_.reset(new PseudoTcpChannelFactory(this));
+  secure_channel_factory_.reset(
+      new SecureChannelFactory(pseudotcp_channel_factory_.get(),
+                               authenticator_.get()));
+
+  SetState(AUTHENTICATED);
+}
+
 void JingleSession::CloseInternal(ErrorCode error) {
   DCHECK(CalledOnValidThread());
 
   if (is_session_active()) {
     // Send session-terminate message with the appropriate error code.
     JingleMessage::Reason reason;
     switch (error) {
       case OK:
         reason = JingleMessage::SUCCESS;
         break;
@@ skipping 41 matching lines @@
   }
 }
 
 bool JingleSession::is_session_active() {
   return state_ == CONNECTING || state_ == ACCEPTING || state_ == CONNECTED ||
         state_ == AUTHENTICATING || state_ == AUTHENTICATED;
 }
 
 }  // namespace protocol
 }  // namespace remoting