Remove PORTALLOCATOR_ENABLE_SHARED_SOCKET.

webrtc/p2p/client/basicportallocator.cc

 /*
  *  Copyright 2004 The WebRTC Project Authors. All rights reserved.
  *
  *  Use of this source code is governed by a BSD-style license
  *  that can be found in the LICENSE file in the root of the source
  *  tree. An additional intellectual property rights grant can be found
  *  in the file PATENTS.  All contributing project authors may
  *  be found in the AUTHORS file in the root of the source tree.
  */
 
@@ skipping 103 matching lines @@
   sigslot::signal1<AllocationSequence*> SignalPortAllocationComplete;
 
  private:
   typedef std::vector<ProtocolType> ProtocolList;
 
   bool IsFlagSet(uint32 flag) {
     return ((flags_ & flag) != 0);
   }
   void CreateUDPPorts();
   void CreateTCPPorts();
-  void CreateStunPorts();
   void CreateRelayPorts();
   void CreateGturnPort(const RelayServerConfig& config);
   void CreateTurnPort(const RelayServerConfig& config);
 
   void OnReadPacket(rtc::AsyncPacketSocket* socket,
                     const char* data, size_t size,
                     const rtc::SocketAddress& remote_addr,
                     const rtc::PacketTime& packet_time);
 
   void OnPortDestroyed(PortInterface* port);
@@ skipping 612 matching lines @@
       ip_(network->GetBestIP()),
       config_(config),
       state_(kInit),
       flags_(flags),
       udp_socket_(),
       udp_port_(NULL),
       phase_(0) {
 }
 
 bool AllocationSequence::Init() {
-  if (IsFlagSet(PORTALLOCATOR_ENABLE_SHARED_SOCKET) &&
-      !IsFlagSet(PORTALLOCATOR_ENABLE_SHARED_UFRAG)) {
-    LOG(LS_ERROR) << "Shared socket option can't be set without "
-                  << "shared ufrag.";
-    ASSERT(false);
-    return false;
+  udp_socket_.reset(session_->socket_factory()->CreateUdpSocket(
+      rtc::SocketAddress(ip_, 0), session_->allocator()->min_port(),
+      session_->allocator()->max_port()));
+  if (udp_socket_) {
+    udp_socket_->SignalReadPacket.connect(
+        this, &AllocationSequence::OnReadPacket);
   }
-
-  if (IsFlagSet(PORTALLOCATOR_ENABLE_SHARED_SOCKET)) {
-    udp_socket_.reset(session_->socket_factory()->CreateUdpSocket(
-        rtc::SocketAddress(ip_, 0), session_->allocator()->min_port(),
-        session_->allocator()->max_port()));
-    if (udp_socket_) {
-      udp_socket_->SignalReadPacket.connect(
-          this, &AllocationSequence::OnReadPacket);
-    }
-    // Continuing if |udp_socket_| is NULL, as local TCP and RelayPort using TCP
-    // are next available options to setup a communication channel.
-  }
+  // Continuing if |udp_socket_| is NULL, as local TCP and RelayPort using TCP
+  // are next available options to setup a communication channel.
   return true;
 }
 
 void AllocationSequence::Clear() {
   udp_port_ = NULL;
   turn_ports_.clear();
 }
 
 AllocationSequence::~AllocationSequence() {
   session_->network_thread()->Clear(this);
@@ skipping 49 matching lines @@
     "Udp", "Relay", "Tcp", "SslTcp"
   };
 
   // Perform all of the phases in the current step.
   LOG_J(LS_INFO, network_) << "Allocation Phase="
                            << PHASE_NAMES[phase_];
 
   switch (phase_) {
     case PHASE_UDP:
       CreateUDPPorts();
-      CreateStunPorts();
       EnableProtocol(PROTO_UDP);
       break;
 
     case PHASE_RELAY:
       CreateRelayPorts();
       break;
 
     case PHASE_TCP:
       CreateTCPPorts();
       EnableProtocol(PROTO_TCP);
@@ skipping 39 matching lines @@
 
 void AllocationSequence::CreateUDPPorts() {
   if (IsFlagSet(PORTALLOCATOR_DISABLE_UDP)) {
     LOG(LS_VERBOSE) << "AllocationSequence: UDP ports disabled, skipping.";
     return;
   }
 
   // TODO(mallinath) - Remove UDPPort creating socket after shared socket
   // is enabled completely.
   UDPPort* port = NULL;
-  if (IsFlagSet(PORTALLOCATOR_ENABLE_SHARED_SOCKET) && udp_socket_) {
-    port = UDPPort::Create(session_->network_thread(),
-                           session_->socket_factory(), network_,
-                           udp_socket_.get(),
-                           session_->username(), session_->password(),
-                           session_->allocator()->origin());
-  } else {
-    port = UDPPort::Create(session_->network_thread(),
-                           session_->socket_factory(),
-                           network_, ip_,
-                           session_->allocator()->min_port(),
-                           session_->allocator()->max_port(),
-                           session_->username(), session_->password(),
-                           session_->allocator()->origin());
-  }
-
+  port = UDPPort::Create(session_->network_thread(),
+                         session_->socket_factory(), network_,
+                         udp_socket_.get(),
+                         session_->username(), session_->password(),
+                         session_->allocator()->origin());
   if (port) {
     // If shared socket is enabled, STUN candidate will be allocated by the
     // UDPPort.
-    if (IsFlagSet(PORTALLOCATOR_ENABLE_SHARED_SOCKET)) {
-      udp_port_ = port;
-      port->SignalDestroyed.connect(this, &AllocationSequence::OnPortDestroyed);
+    udp_port_ = port;
+    port->SignalDestroyed.connect(this, &AllocationSequence::OnPortDestroyed);
 
-      // If STUN is not disabled, setting stun server address to port.
-      if (!IsFlagSet(PORTALLOCATOR_DISABLE_STUN)) {
-        if (config_ && !config_->StunServers().empty()) {
-          LOG(LS_INFO) << "AllocationSequence: UDPPort will be handling the "
-                       <<  "STUN candidate generation.";
-          port->set_server_addresses(config_->StunServers());
-        }
+    // If STUN is not disabled, setting stun server address to port.
+    if (!IsFlagSet(PORTALLOCATOR_DISABLE_STUN)) {
+      if (config_ && !config_->StunServers().empty()) {
+        LOG(LS_INFO) << "AllocationSequence: UDPPort will be handling the "
+                     <<  "STUN candidate generation.";
+        port->set_server_addresses(config_->StunServers());
       }
     }
 
     session_->AddAllocatedPort(port, this, true);
   }
 }
 
 void AllocationSequence::CreateTCPPorts() {
   if (IsFlagSet(PORTALLOCATOR_DISABLE_TCP)) {
     LOG(LS_VERBOSE) << "AllocationSequence: TCP ports disabled, skipping.";
     return;
   }
 
   Port* port = TCPPort::Create(session_->network_thread(),
                                session_->socket_factory(),
                                network_, ip_,
                                session_->allocator()->min_port(),
                                session_->allocator()->max_port(),
                                session_->username(), session_->password(),
                                session_->allocator()->allow_tcp_listen());
   if (port) {
     session_->AddAllocatedPort(port, this, true);
     // Since TCPPort is not created using shared socket, |port| will not be
     // added to the dequeue.
   }
 }
 
-void AllocationSequence::CreateStunPorts() {
-  if (IsFlagSet(PORTALLOCATOR_DISABLE_STUN)) {
-    LOG(LS_VERBOSE) << "AllocationSequence: STUN ports disabled, skipping.";
-    return;
-  }
-
-  if (IsFlagSet(PORTALLOCATOR_ENABLE_SHARED_SOCKET)) {
-    return;
-  }
-
-  if (!(config_ && !config_->StunServers().empty())) {
-    LOG(LS_WARNING)
-        << "AllocationSequence: No STUN server configured, skipping.";
-    return;
-  }
-
-  StunPort* port = StunPort::Create(session_->network_thread(),
-                                session_->socket_factory(),
-                                network_, ip_,
-                                session_->allocator()->min_port(),
-                                session_->allocator()->max_port(),
-                                session_->username(), session_->password(),
-                                config_->StunServers(),
-                                session_->allocator()->origin());
-  if (port) {
-    session_->AddAllocatedPort(port, this, true);
-    // Since StunPort is not created using shared socket, |port| will not be
-    // added to the dequeue.
-  }
-}
-
 void AllocationSequence::CreateRelayPorts() {
   if (IsFlagSet(PORTALLOCATOR_DISABLE_RELAY)) {
      LOG(LS_VERBOSE) << "AllocationSequence: Relay ports disabled, skipping.";
      return;
   }
 
   // If BasicPortAllocatorSession::OnAllocate left relay ports enabled then we
   // ought to have a relay list for them here.
   ASSERT(config_ && !config_->relays.empty());
   if (!(config_ && !config_->relays.empty())) {
@@ skipping 48 matching lines @@
 
 void AllocationSequence::CreateTurnPort(const RelayServerConfig& config) {
   PortList::const_iterator relay_port;
   for (relay_port = config.ports.begin();
        relay_port != config.ports.end(); ++relay_port) {
     TurnPort* port = NULL;
     // Shared socket mode must be enabled only for UDP based ports. Hence
     // don't pass shared socket for ports which will create TCP sockets.
     // TODO(mallinath) - Enable shared socket mode for TURN ports. Disabled
     // due to webrtc bug https://code.google.com/p/webrtc/issues/detail?id=3537
-    if (IsFlagSet(PORTALLOCATOR_ENABLE_SHARED_SOCKET) &&
-        relay_port->proto == PROTO_UDP) {
+    if (relay_port->proto == PROTO_UDP) {
       port = TurnPort::Create(session_->network_thread(),
                               session_->socket_factory(),
                               network_, udp_socket_.get(),
                               session_->username(), session_->password(),
                               *relay_port, config.credentials, config.priority,
                               session_->allocator()->origin());
       turn_ports_.push_back(port);
       // Listen to the port destroyed signal, to allow AllocationSequence to
       // remove entrt from it's map.
       port->SignalDestroyed.connect(this, &AllocationSequence::OnPortDestroyed);
@@ skipping 131 matching lines @@
   ServerAddresses servers;
   for (size_t i = 0; i < relays.size(); ++i) {
     if (relays[i].type == turn_type && SupportsProtocol(relays[i], type)) {
       servers.insert(relays[i].ports.front().address);
     }
   }
   return servers;
 }
 
 }  // namespace cricket