Add support for multiplexed channels in remoting::protocol::Session interface.

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/stl_util.h"
 #include "base/string_number_conversions.h"
 #include "base/time.h"
 #include "remoting/base/constants.h"
 #include "remoting/jingle_glue/iq_sender.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/session_config.h"
 #include "third_party/libjingle/source/talk/p2p/base/candidate.h"
 #include "third_party/libjingle/source/talk/xmllite/xmlelement.h"
 
 using buzz::XmlElement;
 
 namespace remoting {
 namespace protocol {
 
 namespace {
 // Delay after candidate creation before sending transport-info
 // message. This is neccessary to be able to pack multiple candidates
 // into one transport-info messages. The value needs to be greater
 // than zero because ports are opened asynchronously in the browser
 // process.
 const int kTransportInfoSendDelayMs = 2;
 
 // How long we should wait for a response from the other end. This
 // value is used for all requests include |session-initiate| and
 // |transport-info|.
 const int kMessageResponseTimeoutSeconds = 10;
 
+// Name of the multiplexed channel.
+const char kMuxChannelName[] = "mux";
+
 ErrorCode AuthRejectionReasonToErrorCode(
     Authenticator::RejectionReason reason) {
   switch (reason) {
     case Authenticator::INVALID_CREDENTIALS:
       return AUTHENTICATION_FAILED;
     case Authenticator::PROTOCOL_ERROR:
       return INCOMPATIBLE_PROTOCOL;
   }
   NOTREACHED();
   return UNKNOWN_ERROR;
 }
 
 }  // namespace
 
 JingleSession::JingleSession(JingleSessionManager* session_manager)
     : session_manager_(session_manager),
       event_handler_(NULL),
       state_(INITIALIZING),
       error_(OK),
       config_is_set_(false) {
 }
 
 JingleSession::~JingleSession() {
+  channel_multiplexer_.reset();
   STLDeleteContainerPointers(pending_requests_.begin(),
                              pending_requests_.end());
   STLDeleteContainerPairSecondPointers(channels_.begin(), channels_.end());
   session_manager_->SessionDestroyed(this);
 }
 
 void JingleSession::SetEventHandler(Session::EventHandler* event_handler) {
   DCHECK(CalledOnValidThread());
   DCHECK(event_handler);
   event_handler_ = event_handler;
@@ skipping 89 matching lines @@
 
   if (authenticator_->state() == Authenticator::ACCEPTED) {
     SetState(AUTHENTICATED);
   } else {
     DCHECK_EQ(authenticator_->state(), Authenticator::WAITING_MESSAGE);
   }
 
   return;
 }
 
+const std::string& JingleSession::jid() {
+  DCHECK(CalledOnValidThread());
+  return peer_jid_;
+}
+
+const CandidateSessionConfig* JingleSession::candidate_config() {
+  DCHECK(CalledOnValidThread());
+  return candidate_config_.get();
+}
+
+const SessionConfig& JingleSession::config() {
+  DCHECK(CalledOnValidThread());
+  return config_;
+}
+
+void JingleSession::set_config(const SessionConfig& config) {
+  DCHECK(CalledOnValidThread());
+  DCHECK(!config_is_set_);
+  config_ = config;
+  config_is_set_ = true;
+}
+
+ChannelFactory* JingleSession::GetTransportChannelFactory() {

[Wez, 2012/08/18 00:30:36]

nit: CalledOnValidThread?

[Sergey Ulanov, 2012/08/18 01:53:56]

Done.

+  return this;
+}
+
+ChannelFactory* JingleSession::GetMultiplexedChannelFactory() {

[Wez, 2012/08/18 00:30:36]

nit: CalledOnValidThread?

[Sergey Ulanov, 2012/08/18 01:53:56]

Done.

+  if (!channel_multiplexer_.get())
+    channel_multiplexer_.reset(new ChannelMultiplexer(this, kMuxChannelName));
+  return channel_multiplexer_.get();
+}
+
+void JingleSession::Close() {
+  DCHECK(CalledOnValidThread());
+
+  CloseInternal(OK);
+}
+
 void JingleSession::CreateStreamChannel(
       const std::string& name,
       const StreamChannelCallback& 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());
@@ skipping 16 matching lines @@
 }
 
 void JingleSession::CancelChannelCreation(const std::string& name) {
   ChannelsMap::iterator it = channels_.find(name);
   if (it != channels_.end() && !it->second->is_connected()) {
     delete it->second;
     DCHECK(!channels_[name]);
   }
 }
 
-const std::string& JingleSession::jid() {
-  DCHECK(CalledOnValidThread());
-  return peer_jid_;
-}
-
-const CandidateSessionConfig* JingleSession::candidate_config() {
-  DCHECK(CalledOnValidThread());
-  return candidate_config_.get();
-}
-
-const SessionConfig& JingleSession::config() {
-  DCHECK(CalledOnValidThread());
-  return config_;
-}
-
-void JingleSession::set_config(const SessionConfig& config) {
-  DCHECK(CalledOnValidThread());
-  DCHECK(!config_is_set_);
-  config_ = config;
-  config_is_set_ = true;
-}
-
-void JingleSession::Close() {
-  DCHECK(CalledOnValidThread());
-
-  CloseInternal(OK);
-}
-
 void JingleSession::OnTransportCandidate(Transport* transport,
                                          const cricket::Candidate& candidate) {
   pending_candidates_.push_back(JingleMessage::NamedCandidate(
       transport->name(), candidate));
 
   if (!transport_infos_timer_.IsRunning()) {
     // Delay sending the new candidates in case we get more candidates
     // that we can send in one message.
     transport_infos_timer_.Start(
         FROM_HERE, base::TimeDelta::FromMilliseconds(kTransportInfoSendDelayMs),
@@ skipping 330 matching lines @@
     DCHECK_NE(state_, FAILED);
 
     state_ = new_state;
     if (event_handler_)
       event_handler_->OnSessionStateChange(new_state);
   }
 }
 
 }  // namespace protocol
 }  // namespace remoting