Relanding Generate localhost candidate when no STUN/TURN and portallocator has the right flag spefi…

webrtc/p2p/base/stunport.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.
  */
 
 #include "webrtc/p2p/base/stunport.h"
 
 #include "webrtc/p2p/base/common.h"
 #include "webrtc/p2p/base/portallocator.h"
 #include "webrtc/p2p/base/stun.h"
 #include "webrtc/base/common.h"
 #include "webrtc/base/helpers.h"
+#include "webrtc/base/ipaddress.h"
 #include "webrtc/base/logging.h"
 #include "webrtc/base/nethelpers.h"
 
 namespace cricket {
 
 // TODO: Move these to a common place (used in relayport too)
 const int KEEPALIVE_DELAY = 10 * 1000;  // 10 seconds - sort timeouts
 const int RETRY_DELAY = 50;             // 50ms, from ICE spec
 const int RETRY_TIMEOUT = 50 * 1000;    // ICE says 50 secs
 
@@ skipping 129 matching lines @@
     }
   }
 }
 
 UDPPort::UDPPort(rtc::Thread* thread,
                  rtc::PacketSocketFactory* factory,
                  rtc::Network* network,
                  rtc::AsyncPacketSocket* socket,
                  const std::string& username,
                  const std::string& password,
-                 const std::string& origin)
+                 const std::string& origin,
+                 bool emit_localhost_for_anyaddress)
     : Port(thread, factory, network, socket->GetLocalAddress().ipaddr(),
            username, password),
       requests_(thread),
       socket_(socket),
       error_(0),
       ready_(false),
-      stun_keepalive_delay_(KEEPALIVE_DELAY) {
+      stun_keepalive_delay_(KEEPALIVE_DELAY),
+      emit_localhost_for_anyaddress_(emit_localhost_for_anyaddress) {
   requests_.set_origin(origin);
 }
 
 UDPPort::UDPPort(rtc::Thread* thread,
                  rtc::PacketSocketFactory* factory,
                  rtc::Network* network,
                  const rtc::IPAddress& ip,
                  uint16 min_port,
                  uint16 max_port,
                  const std::string& username,
                  const std::string& password,
-                 const std::string& origin)
+                 const std::string& origin,
+                 bool emit_localhost_for_anyaddress)
     : Port(thread, LOCAL_PORT_TYPE, factory, network, ip, min_port, max_port,
            username, password),
       requests_(thread),
       socket_(NULL),
       error_(0),
       ready_(false),
-      stun_keepalive_delay_(KEEPALIVE_DELAY) {
+      stun_keepalive_delay_(KEEPALIVE_DELAY),
+      emit_localhost_for_anyaddress_(emit_localhost_for_anyaddress) {
   requests_.set_origin(origin);
 }
 
 bool UDPPort::Init() {
   if (!SharedSocket()) {
     ASSERT(socket_ == NULL);
     socket_ = socket_factory()->CreateUdpSocket(
         rtc::SocketAddress(ip(), 0), min_port(), max_port());
     if (!socket_) {
       LOG_J(LS_WARNING, this) << "UDP socket creation failed";
@@ skipping 69 matching lines @@
 int UDPPort::GetOption(rtc::Socket::Option opt, int* value) {
   return socket_->GetOption(opt, value);
 }
 
 int UDPPort::GetError() {
   return error_;
 }
 
 void UDPPort::OnLocalAddressReady(rtc::AsyncPacketSocket* socket,
                                   const rtc::SocketAddress& address) {
-  AddAddress(address, address, rtc::SocketAddress(), UDP_PROTOCOL_NAME, "", "",
+  // When adapter enumeration is disabled and binding to the any address, the
+  // loopback address will be issued as a candidate instead if
+  // |emit_localhost_for_anyaddress| is true. This is to allow connectivity on
+  // demo pages without STUN/TURN to work.
+  rtc::SocketAddress addr = address;
+  if (addr.IsAnyIP() && emit_localhost_for_anyaddress_) {
+    addr.SetIP(rtc::GetLoopbackIP(addr.family()));
+  }
+
+  AddAddress(addr, addr, rtc::SocketAddress(), UDP_PROTOCOL_NAME, "", "",
              LOCAL_PORT_TYPE, ICE_TYPE_PREFERENCE_HOST, 0, false);
   MaybePrepareStunCandidate();
 }
 
 void UDPPort::OnReadPacket(
   rtc::AsyncPacketSocket* socket, const char* data, size_t size,
   const rtc::SocketAddress& remote_addr,
   const rtc::PacketTime& packet_time) {
   ASSERT(socket == socket_);
   ASSERT(!remote_addr.IsUnresolved());
@@ skipping 155 matching lines @@
   const std::vector<Candidate>& existing_candidates = Candidates();
   std::vector<Candidate>::const_iterator it = existing_candidates.begin();
   for (; it != existing_candidates.end(); ++it) {
     if (it->address() == addr)
       return true;
   }
   return false;
 }
 
 }  // namespace cricket