Add DISABLE_TCP_TRANSPORT flag in the Transport API.

content/renderer/p2p/port_allocator.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/port_allocator.h"
 
 #include "base/bind.h"
 #include "base/string_number_conversions.h"
 #include "base/string_split.h"
 #include "base/string_util.h"
 #include "content/renderer/p2p/host_address_request.h"
 #include "jingle/glue/utils.h"
 #include "net/base/ip_endpoint.h"
+#include "ppapi/c/dev/ppb_transport_dev.h"
 #include "third_party/WebKit/Source/WebKit/chromium/public/WebFrame.h"
 #include "third_party/WebKit/Source/WebKit/chromium/public/WebURLError.h"
 #include "third_party/WebKit/Source/WebKit/chromium/public/WebURLLoader.h"
 #include "third_party/WebKit/Source/WebKit/chromium/public/WebURLLoaderOptions.h"
 #include "third_party/WebKit/Source/WebKit/chromium/public/WebURLRequest.h"
 #include "third_party/WebKit/Source/WebKit/chromium/public/WebURLResponse.h"
 
 using WebKit::WebString;
 using WebKit::WebURL;
 using WebKit::WebURLLoader;
@@ skipping 28 matching lines @@
 P2PPortAllocator::P2PPortAllocator(
     WebKit::WebFrame* web_frame,
     P2PSocketDispatcher* socket_dispatcher,
     talk_base::NetworkManager* network_manager,
     talk_base::PacketSocketFactory* socket_factory,
     const webkit_glue::P2PTransport::Config& config)
     : cricket::BasicPortAllocator(network_manager, socket_factory),
       web_frame_(web_frame),
       socket_dispatcher_(socket_dispatcher),
       config_(config) {
+  uint32 flags = 0;
+  if (config_.protocols & PP_TRANSPORTPROTOCOL_UDP)
+    flags |= cricket::PORTALLOCATOR_DISABLE_UDP;
+  if (config_.protocols & PP_TRANSPORTPROTOCOL_TCP)
+    flags |= cricket::PORTALLOCATOR_DISABLE_TCP;
+  if (config_.protocols & PP_TRANSPORTPROTOCOL_STUN)
+    flags |= cricket::PORTALLOCATOR_DISABLE_STUN;
+  if ((config_.protocols & PP_TRANSPORTPROTOCOL_RELAY_UDP) &&
+      (config_.protocols & PP_TRANSPORTPROTOCOL_RELAY_TCP) &&
+      (config_.protocols & PP_TRANSPORTPROTOCOL_RELAY_SSLTCP)) {
+    flags |= cricket::PORTALLOCATOR_DISABLE_RELAY;
+  }
+  set_flags(flags);
 }
 
 P2PPortAllocator::~P2PPortAllocator() {
 }
 
 cricket::PortAllocatorSession* P2PPortAllocator::CreateSession(
     const std::string& name,
     const std::string& session_type) {
   return new P2PPortAllocatorSession(this, name, session_type);
 }
@@ skipping 47 matching lines @@
       talk_base::SocketAddress(), "", "", ""));
 
   ResolveStunServerAddress();
   AllocateRelaySession();
 }
 
 void P2PPortAllocatorSession::ResolveStunServerAddress() {
  if (allocator_->config_.stun_server.empty())
    return;
 
+ if (allocator_->config_.protocols & PP_TRANSPORTPROTOCOL_STUN)
+   return;
+
  DCHECK(!stun_address_request_);
  stun_address_request_ =
      new P2PHostAddressRequest(allocator_->socket_dispatcher_);
  stun_address_request_->Request(allocator_->config_.stun_server, base::Bind(
      &P2PPortAllocatorSession::OnStunServerAddress,
      base::Unretained(this)));
 }
 
 void P2PPortAllocatorSession::OnStunServerAddress(
     const net::IPAddressNumber& address) {
   if (address.empty()) {
     LOG(ERROR) << "Failed to resolve STUN server address "
                << allocator_->config_.stun_server;
     return;
   }
 
   if (!jingle_glue::IPEndPointToSocketAddress(
           net::IPEndPoint(address, allocator_->config_.stun_server_port),
           &stun_server_address_)) {
     return;
   }
 
   AddConfig();
 }
 
 void P2PPortAllocatorSession::AllocateRelaySession() {
   if (allocator_->config_.relay_server.empty())
     return;
 
+ if ((allocator_->config_.protocols & PP_TRANSPORTPROTOCOL_RELAY_UDP) &&
+     (allocator_->config_.protocols & PP_TRANSPORTPROTOCOL_RELAY_TCP) &&
+     (allocator_->config_.protocols & PP_TRANSPORTPROTOCOL_RELAY_SSLTCP)) {
+   return;
+ }
+
   if (!allocator_->config_.legacy_relay) {
     NOTIMPLEMENTED() << " TURN support is not implemented yet.";
     return;
   }
 
   if (relay_session_attemtps_ > kRelaySessionRetries)
     return;
   relay_session_attemtps_++;
 
   relay_session_response_.clear();
@@ skipping 78 matching lines @@
   AddConfig();
 }
 
 void P2PPortAllocatorSession::AddConfig() {
   cricket::PortConfiguration* config =
       new cricket::PortConfiguration(stun_server_address_,
                                      relay_username_, relay_password_, "");
 
   cricket::PortConfiguration::PortList ports;
   if (relay_ip_.ip() != 0) {
-    if (relay_udp_port_ > 0) {
+    if (relay_udp_port_ > 0 &&
+        (allocator_->config_.protocols & PP_TRANSPORTPROTOCOL_RELAY_UDP)) {

[juberti, 2011/09/13 21:14:19]

Why do we care what protocol the remote side uses to talk to the relay server?

[Sergey Ulanov, 2011/09/13 21:55:49]

For chromoting we disable TCP ports because they provide poor performance with
PseudoTCP. For the same reason we need to disable relay_tcp and relay_ssltcp.

The performance problem when running PseudoTCP over TCP can be fixed, but it
would require some changes in libjingle: AsyncPacketSocket interface and its
implementation would need to handle blocking sends properly. Currently
AsyncTCPSocket and AsyncUDPSocket simply drop outgoing packets when write cannot
be completed synchronously. PseudoTCP interprets dropped packets as network
congestion even when they are not caused by network congestion, which causes
PseudoTCP to shrink congestion window.

       talk_base::SocketAddress address(relay_ip_.ip(), relay_udp_port_);
       ports.push_back(cricket::ProtocolAddress(address, cricket::PROTO_UDP));
     }
-    if (relay_tcp_port_ > 0) {
+    if (relay_tcp_port_ > 0 &&
+        (allocator_->config_.protocols & PP_TRANSPORTPROTOCOL_RELAY_TCP)) {
       talk_base::SocketAddress address(relay_ip_.ip(), relay_tcp_port_);
       ports.push_back(cricket::ProtocolAddress(address, cricket::PROTO_TCP));
     }
-    if (relay_ssltcp_port_ > 0) {
+    if (relay_ssltcp_port_ > 0 &&
+        (allocator_->config_.protocols & PP_TRANSPORTPROTOCOL_RELAY_SSLTCP)) {
       talk_base::SocketAddress address(relay_ip_.ip(), relay_ssltcp_port_);
       ports.push_back(cricket::ProtocolAddress(address, cricket::PROTO_SSLTCP));
     }
   }
   config->AddRelay(ports, 0.0f);
   ConfigReady(config);
 }
 
 }  // namespace content