Implement STUN support for P2P Transport API.

content/renderer/p2p/p2p_transport_impl.cc

 // Copyright (c) 2011 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 "content/renderer/p2p/p2p_transport_impl.h"
 
 #include "content/renderer/p2p/ipc_network_manager.h"
 #include "content/renderer/p2p/ipc_socket_factory.h"
+#include "content/renderer/p2p/port_allocator.h"
 #include "content/renderer/render_view.h"
 #include "jingle/glue/channel_socket_adapter.h"
 #include "jingle/glue/pseudotcp_adapter.h"
 #include "jingle/glue/thread_wrapper.h"
 #include "jingle/glue/utils.h"
 #include "net/base/net_errors.h"
 #include "third_party/libjingle/source/talk/p2p/base/p2ptransportchannel.h"
 #include "third_party/libjingle/source/talk/p2p/client/basicportallocator.h"
 
 namespace content {
 
 P2PTransportImpl::P2PTransportImpl(
     talk_base::NetworkManager* network_manager,
     talk_base::PacketSocketFactory* socket_factory)
-    : event_handler_(NULL),
+    : socket_dispatcher_(NULL),
+      event_handler_(NULL),
       state_(STATE_NONE),
       network_manager_(network_manager),
       socket_factory_(socket_factory),
       ALLOW_THIS_IN_INITIALIZER_LIST(connect_callback_(
           this, &P2PTransportImpl::OnTcpConnected)) {
 }
 
 P2PTransportImpl::P2PTransportImpl(P2PSocketDispatcher* socket_dispatcher)
-    : event_handler_(NULL),
+    : socket_dispatcher_(socket_dispatcher),
+      event_handler_(NULL),
       state_(STATE_NONE),
       network_manager_(new IpcNetworkManager(socket_dispatcher)),
       socket_factory_(new IpcPacketSocketFactory(socket_dispatcher)),
       ALLOW_THIS_IN_INITIALIZER_LIST(connect_callback_(
           this, &P2PTransportImpl::OnTcpConnected)) {
+  DCHECK(socket_dispatcher);
 }
 
 P2PTransportImpl::~P2PTransportImpl() {
 }
 
 bool P2PTransportImpl::Init(const std::string& name,
                             Protocol protocol,
                             const Config& config,
                             EventHandler* event_handler) {
   DCHECK(event_handler);
 
   // Before proceeding, ensure we have libjingle thread wrapper for
   // the current thread.
   jingle_glue::JingleThreadWrapper::EnsureForCurrentThread();
 
   name_ = name;
   event_handler_ = event_handler;
 
-  // TODO(sergeyu): Use STUN/Relay settings from |config|.
-  allocator_.reset(new cricket::BasicPortAllocator(
-      network_manager_.get(), socket_factory_.get()));
+  if (socket_dispatcher_) {
+    allocator_.reset(new P2PPortAllocator(
+        socket_dispatcher_, network_manager_.get(),
+        socket_factory_.get(), config));
+  } else {
+    // Use raw basic port allocator is used for tests.

[Wez, 2011/08/29 18:01:57]

This comment needs rewording, although it could just be removed, I think, since
the test-only limitation is specified on the ctor definition already.

Is the P2P vs Basic port allocator usage here correct?  What does an application
do if it wants LAN-only peer-to-peer?  Seems preferable to avoid unnecessary
work on STUN, etc, in that case?

[Sergey Ulanov, 2011/08/29 22:13:39]

I think it's useful to have this comment here.
I plan to add flags to disable/enable certain types of ports. These flags will
be passed to P2PPortAllocator (as part of |config|). P2PPortAllocator will not
do any additional work if some ports are disabled.

+    allocator_.reset(new cricket::BasicPortAllocator(
+        network_manager_.get(), socket_factory_.get()));
+  }
 
   DCHECK(!channel_.get());
   channel_.reset(new cricket::P2PTransportChannel(
       name, "", NULL, allocator_.get()));
   channel_->SignalRequestSignaling.connect(
       this, &P2PTransportImpl::OnRequestSignaling);
   channel_->SignalCandidateReady.connect(
       this, &P2PTransportImpl::OnCandidateReady);
 
   if (protocol == PROTOCOL_UDP) {
@@ skipping 64 matching lines @@
 void P2PTransportImpl::OnTcpConnected(int result) {
   if (result < 0) {
     event_handler_->OnError(result);
     return;
   }
   state_ = static_cast<State>(STATE_READABLE | STATE_WRITABLE);
   event_handler_->OnStateChange(state_);
 }
 
 }  // namespace content