Add TransportContext class.

remoting/protocol/ice_transport.cc

 // Copyright 2015 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/ice_transport.h"
 
 #include "base/bind.h"
 #include "remoting/protocol/channel_authenticator.h"
 #include "remoting/protocol/channel_multiplexer.h"
 #include "remoting/protocol/pseudotcp_channel_factory.h"
 #include "remoting/protocol/secure_channel_factory.h"
 #include "remoting/protocol/stream_channel_factory.h"
+#include "remoting/protocol/transport_context.h"
 
 namespace remoting {
 namespace protocol {
 
 // Delay after candidate creation before sending transport-info message to
 // accumulate multiple candidates. This is an optimization to reduce number of
 // transport-info messages.
 const int kTransportInfoSendDelayMs = 20;
 
 // Name of the multiplexed channel.
 static const char kMuxChannelName[] = "mux";
 
-IceTransport::IceTransport(cricket::PortAllocator* port_allocator,
-                           const NetworkSettings& network_settings,
-                           TransportRole role)
-    : port_allocator_(port_allocator),
-      network_settings_(network_settings),
-      role_(role),
-      weak_factory_(this) {}
+IceTransport::IceTransport(scoped_refptr<TransportContext> transport_context)
+    : transport_context_(transport_context), weak_factory_(this) {
+  transport_context->Prepare();
+}
 
 IceTransport::~IceTransport() {
   channel_multiplexer_.reset();
   DCHECK(channels_.empty());
 }
 
-base::Closure IceTransport::GetCanStartClosure() {
-  return base::Bind(&IceTransport::OnCanStart,
-                    weak_factory_.GetWeakPtr());
-}
-
 void IceTransport::Start(Transport::EventHandler* event_handler,
                          Authenticator* authenticator) {
   DCHECK(event_handler);
   DCHECK(!event_handler_);
 
   event_handler_ = event_handler;
   pseudotcp_channel_factory_.reset(new PseudoTcpChannelFactory(this));
   secure_channel_factory_.reset(new SecureChannelFactory(
       pseudotcp_channel_factory_.get(), authenticator));
 }
@@ skipping 35 matching lines @@
 }
 
 StreamChannelFactory* IceTransport::GetMultiplexedChannelFactory() {
   if (!channel_multiplexer_.get()) {
     channel_multiplexer_.reset(
         new ChannelMultiplexer(GetStreamChannelFactory(), kMuxChannelName));
   }
   return channel_multiplexer_.get();
 }
 
-void IceTransport::OnCanStart() {
-  DCHECK(!can_start_);
-
-  can_start_ = true;
-  for (ChannelsMap::iterator it = channels_.begin(); it != channels_.end();
-       ++it) {
-    it->second->OnCanStart();
-  }
-}
-
 void IceTransport::CreateChannel(const std::string& name,
                                  const ChannelCreatedCallback& callback) {
   DCHECK(!channels_[name]);
 
   scoped_ptr<IceTransportChannel> channel(
-      new IceTransportChannel(port_allocator_, network_settings_, role_));
-  if (can_start_)
-    channel->OnCanStart();
+      new IceTransportChannel(transport_context_));
   channel->Connect(name, this, callback);
   AddPendingRemoteTransportInfo(channel.get());
   channels_[name] = channel.release();
 }
 
 void IceTransport::CancelChannelCreation(const std::string& name) {
   ChannelsMap::iterator it = channels_.find(name);
   if (it != channels_.end()) {
     DCHECK(!it->second->is_connected());
     delete it->second;
@@ skipping 72 matching lines @@
   }
 }
 
 void IceTransport::SendTransportInfo() {
   DCHECK(pending_transport_info_message_);
   event_handler_->OnOutgoingTransportInfo(
       pending_transport_info_message_->ToXml());
   pending_transport_info_message_.reset();
 }
 
+IceTransportFactory::IceTransportFactory(
+    scoped_refptr<TransportContext> transport_context)
+    : transport_context_(transport_context) {}
+
+IceTransportFactory::~IceTransportFactory() {}
+
+scoped_ptr<Transport> IceTransportFactory::CreateTransport() {
+  return make_scoped_ptr(new IceTransport(transport_context_.get()));
+}
+
 }  // namespace protocol
 }  // namespace remoting