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/authenticated_channel_factory.h"
 #include "remoting/protocol/authenticator.h"
 #include "remoting/protocol/channel_authenticator.h"
+#include "remoting/protocol/channel_factory.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/session_config.h"
 #include "remoting/signaling/iq_sender.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 {
 
@@ skipping 149 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 12 matching lines @@
 
 void JingleSession::set_config(const SessionConfig& config) {
   DCHECK(CalledOnValidThread());
   DCHECK(!config_is_set_);
   config_ = config;
   config_is_set_ = true;
 }
 
 ChannelFactory* JingleSession::GetTransportChannelFactory() {
   DCHECK(CalledOnValidThread());
-  return this;
+  return authenticated_channel_factory_.get();
 }
 
 ChannelFactory* 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());
+  scoped_ptr<Transport> channel =
+      session_manager_->transport_factory_->CreateTransport();
+  channel->Initialize(name, this);
   channel->Connect(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()) {
     delete it->second;
     DCHECK(!channels_[name]);
@@ skipping 319 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));
+  authenticated_channel_factory_.reset(new AuthenticatedChannelFactory(
+      pseudotcp_channel_factory_.get(), authenticator_.get()));

[Wez, 2014/09/10 02:29:26]

nit: Although it's an extra line, I'd suggest wrapping before new and before
authenticator, for readability.

[Sergey Ulanov, 2014/09/10 21:50:58]

Done.

+
+  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