Pass TransportConfig to TransportFactory instead of Transport.

remoting/protocol/libjingle_transport_factory.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/libjingle_transport_factory.h"
 
 #include "base/message_loop_proxy.h"
 #include "jingle/glue/channel_socket_adapter.h"
 #include "jingle/glue/pseudotcp_adapter.h"
 #include "jingle/glue/utils.h"
 #include "net/base/net_errors.h"
 #include "remoting/base/constants.h"
 #include "remoting/protocol/channel_authenticator.h"
 #include "remoting/protocol/transport_config.h"
 #include "third_party/libjingle/source/talk/base/basicpacketsocketfactory.h"
 #include "third_party/libjingle/source/talk/base/network.h"
 #include "third_party/libjingle/source/talk/p2p/base/p2ptransportchannel.h"
 #include "third_party/libjingle/source/talk/p2p/client/basicportallocator.h"
+#include "third_party/libjingle/source/talk/p2p/client/httpportallocator.h"
 
 namespace remoting {
 namespace protocol {
 
 namespace {
 
 // Value is choosen to balance the extra latency against the reduced
 // load due to ACK traffic.
 const int kTcpAckDelayMilliseconds = 10;
 
 // Values for the TCP send and receive buffer size. This should be tuned to
 // accomodate high latency network but not backlog the decoding pipeline.
 const int kTcpReceiveBufferSize = 256 * 1024;
 const int kTcpSendBufferSize = kTcpReceiveBufferSize + 30 * 1024;
 
 class LibjingleStreamTransport : public StreamTransport,
                                  public sigslot::has_slots<> {
  public:
   LibjingleStreamTransport(cricket::PortAllocator* port_allocator,
                            bool incoming_only);
   virtual ~LibjingleStreamTransport();
 
   // StreamTransport interface.
   virtual void Initialize(
       const std::string& name,
-      const TransportConfig& config,
       Transport::EventHandler* event_handler,
       scoped_ptr<ChannelAuthenticator> authenticator) OVERRIDE;
   virtual void Connect(
       const StreamTransport::ConnectedCallback& callback) OVERRIDE;
   virtual void AddRemoteCandidate(const cricket::Candidate& candidate) OVERRIDE;
   virtual const std::string& name() const OVERRIDE;
   virtual bool is_connected() const OVERRIDE;
 
  private:
   void OnRequestSignaling(cricket::TransportChannelImpl* channel);
   void OnCandidateReady(cricket::TransportChannelImpl* channel,
                         const cricket::Candidate& candidate);
   void OnRouteChange(cricket::TransportChannel* channel,
                      const cricket::Candidate& candidate);
 
   void OnTcpConnected(int result);
   void OnAuthenticationDone(net::Error error,
                             scoped_ptr<net::StreamSocket> socket);
 
   void OnChannelDestroyed();
 
   void NotifyConnected(scoped_ptr<net::StreamSocket> socket);
   void NotifyConnectFailed();
 
   cricket::PortAllocator* port_allocator_;
   bool incoming_only_;
 
   std::string name_;
-  TransportConfig config_;
   EventHandler* event_handler_;
   StreamTransport::ConnectedCallback callback_;
   scoped_ptr<ChannelAuthenticator> authenticator_;
 
   scoped_ptr<cricket::P2PTransportChannel> channel_;
 
   // We own |socket_| until it is connected.
   scoped_ptr<jingle_glue::PseudoTcpAdapter> socket_;
 
   DISALLOW_COPY_AND_ASSIGN(LibjingleStreamTransport);
@@ skipping 14 matching lines @@
   DCHECK(!is_connected() || socket_.get() == NULL);
 
   if (channel_.get()) {
     base::MessageLoopProxy::current()->DeleteSoon(
         FROM_HERE, channel_.release());
   }
 }
 
 void LibjingleStreamTransport::Initialize(
     const std::string& name,
-    const TransportConfig& config,
     Transport::EventHandler* event_handler,
     scoped_ptr<ChannelAuthenticator> authenticator) {
   DCHECK(CalledOnValidThread());
 
   DCHECK(!name.empty());
   DCHECK(event_handler);
 
   // Can be initialized only once.
   DCHECK(name_.empty());
 
   name_ = name;
-  config_ = config;
   event_handler_ = event_handler;
   authenticator_ = authenticator.Pass();
 }
 
 void LibjingleStreamTransport::Connect(
     const StreamTransport::ConnectedCallback& callback) {
   DCHECK(CalledOnValidThread());
 
   callback_ = callback;
 
@@ skipping 156 matching lines @@
   authenticator_.reset();
 
   NotifyConnected(scoped_ptr<net::StreamSocket>(NULL));
 }
 
 }  // namespace
 
 LibjingleTransportFactory::LibjingleTransportFactory(
     scoped_ptr<talk_base::NetworkManager> network_manager,
     scoped_ptr<talk_base::PacketSocketFactory> socket_factory,
-    scoped_ptr<cricket::PortAllocator> port_allocator,
+    scoped_ptr<cricket::HttpPortAllocatorBase> port_allocator,
     bool incoming_only)
     : network_manager_(network_manager.Pass()),
       socket_factory_(socket_factory.Pass()),
+      http_port_allocator_(port_allocator.get()),
       port_allocator_(port_allocator.Pass()),
       incoming_only_(incoming_only) {
 }
 
 LibjingleTransportFactory::LibjingleTransportFactory()
     : network_manager_(new talk_base::BasicNetworkManager()),
       socket_factory_(new talk_base::BasicPacketSocketFactory()),
+      http_port_allocator_(NULL),
       port_allocator_(new cricket::BasicPortAllocator(
           network_manager_.get(), socket_factory_.get())),
       incoming_only_(false) {
 }
 
 LibjingleTransportFactory::~LibjingleTransportFactory() {
   // This method may be called in response to a libjingle signal, so
   // libjingle objects must be deleted asynchronously.
   base::MessageLoopProxy::current()->DeleteSoon(
       FROM_HERE, port_allocator_.release());
   base::MessageLoopProxy::current()->DeleteSoon(
       FROM_HERE, socket_factory_.release());
   base::MessageLoopProxy::current()->DeleteSoon(
       FROM_HERE, network_manager_.release());
 }
 
+void LibjingleTransportFactory::SetTransportConfig(
+    const TransportConfig& config) {
+  if (http_port_allocator_) {
+    std::vector<talk_base::SocketAddress> stun_hosts;
+    talk_base::SocketAddress stun_address;
+    if (stun_address.FromString(config.stun_server)) {
+      stun_hosts.push_back(stun_address);
+      http_port_allocator_->SetStunHosts(stun_hosts);
+    } else {
+      LOG(ERROR) << "Failed to parse stun server address: "
+                 << config.stun_server;
+    }
+
+    std::vector<std::string> relay_hosts;
+    relay_hosts.push_back(config.relay_server);
+    http_port_allocator_->SetRelayHosts(relay_hosts);
+    http_port_allocator_->SetRelayToken(config.relay_token);
+  }
+}
+
 scoped_ptr<StreamTransport> LibjingleTransportFactory::CreateStreamTransport() {
   return scoped_ptr<StreamTransport>(
       new LibjingleStreamTransport(port_allocator_.get(), incoming_only_));
 }
 
 scoped_ptr<DatagramTransport>
 LibjingleTransportFactory::CreateDatagramTransport() {
   NOTIMPLEMENTED();
   return scoped_ptr<DatagramTransport>(NULL);
 }
 
 }  // namespace protocol
 }  // namespace remoting