Make Port (and subclasses) fully "Network"-based, instead of IP-based.

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 1078 matching lines @@
 }
 
 // AllocationSequence
 
 AllocationSequence::AllocationSequence(BasicPortAllocatorSession* session,
                                        rtc::Network* network,
                                        PortConfiguration* config,
                                        uint32_t flags)
     : session_(session),
       network_(network),
-      ip_(network->GetBestIP()),
       config_(config),
       state_(kInit),
       flags_(flags),
       udp_socket_(),
       udp_port_(NULL),
       phase_(0) {
 }
 
 void AllocationSequence::Init() {
   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()));
+        rtc::SocketAddress(network_->GetBestIP(), 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.
   }
 }
 
 void AllocationSequence::Clear() {
@@ skipping 13 matching lines @@
 }
 
 void AllocationSequence::DisableEquivalentPhases(rtc::Network* network,
     PortConfiguration* config, uint32_t* flags) {
   if (network_failed_) {
     // If the network of this allocation sequence has ever become failed,
     // it won't be equivalent to the new network.
     return;
   }
 
-  if (!((network == network_) && (ip_ == network->GetBestIP()))) {
+  if (!((network == network_) && (previous_best_ip_ == network->GetBestIP()))) {
     // Different network setup; nothing is equivalent.
     return;
   }
 
   // Else turn off the stuff that we've already got covered.
 
   // Every config implicitly specifies local, so turn that off right away.
   *flags |= PORTALLOCATOR_DISABLE_UDP;
   *flags |= PORTALLOCATOR_DISABLE_TCP;
 
   if (config_ && config) {
     if (config_->StunServers() == config->StunServers()) {
       // Already got this STUN servers covered.
       *flags |= PORTALLOCATOR_DISABLE_STUN;
     }
     if (!config_->relays.empty()) {
       // Already got relays covered.
       // NOTE: This will even skip a _different_ set of relay servers if we
       // were to be given one, but that never happens in our codebase. Should
       // probably get rid of the list in PortConfiguration and just keep a
       // single relay server in each one.
       *flags |= PORTALLOCATOR_DISABLE_RELAY;
     }
   }
 }
 
 void AllocationSequence::Start() {
   state_ = kRunning;
   session_->network_thread()->Post(RTC_FROM_HERE, this, MSG_ALLOCATION_PHASE);
+  // Take a snapshot of the best IP, so that when DisableEquivalentPhases is
+  // called next time, we enable all phases if the best IP has since changed.
+  previous_best_ip_ = network_->GetBestIP();
 }
 
 void AllocationSequence::Stop() {
   // If the port is completed, don't set it to stopped.
   if (state_ == kRunning) {
     state_ = kStopped;
     session_->network_thread()->Clear(this, MSG_ALLOCATION_PHASE);
   }
 }
 
@@ skipping 74 matching lines @@
   UDPPort* port = NULL;
   bool emit_local_candidate_for_anyaddress =
       !IsFlagSet(PORTALLOCATOR_DISABLE_DEFAULT_LOCAL_CANDIDATE);
   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(), emit_local_candidate_for_anyaddress);
   } else {
     port = UDPPort::Create(
-        session_->network_thread(), session_->socket_factory(), network_, ip_,
+        session_->network_thread(), session_->socket_factory(), network_,
         session_->allocator()->min_port(), session_->allocator()->max_port(),
         session_->username(), session_->password(),
         session_->allocator()->origin(), emit_local_candidate_for_anyaddress);
   }
 
   if (port) {
     // If shared socket is enabled, STUN candidate will be allocated by the
     // UDPPort.
     if (IsFlagSet(PORTALLOCATOR_ENABLE_SHARED_SOCKET)) {
       udp_port_ = port;
@@ skipping 12 matching lines @@
     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());
+  Port* port = TCPPort::Create(
+      session_->network_thread(), session_->socket_factory(), network_,
+      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());
+  StunPort* port = StunPort::Create(
+      session_->network_thread(), session_->socket_factory(), network_,
+      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.";
@@ skipping 15 matching lines @@
     } else if (relay.type == RELAY_TURN) {
       CreateTurnPort(relay);
     } else {
       RTC_NOTREACHED();
     }
   }
 }
 
 void AllocationSequence::CreateGturnPort(const RelayServerConfig& config) {
   // TODO(mallinath) - Rename RelayPort to GTurnPort.
-  RelayPort* port = RelayPort::Create(session_->network_thread(),
-                                      session_->socket_factory(),
-                                      network_, ip_,
-                                      session_->allocator()->min_port(),
-                                      session_->allocator()->max_port(),
-                                      config_->username, config_->password);
+  RelayPort* port = RelayPort::Create(
+      session_->network_thread(), session_->socket_factory(), network_,
+      session_->allocator()->min_port(), session_->allocator()->max_port(),
+      config_->username, config_->password);
   if (port) {
     // Since RelayPort is not created using shared socket, |port| will not be
     // added to the dequeue.
     // Note: We must add the allocated port before we add addresses because
     //       the latter will create candidates that need name and preference
     //       settings.  However, we also can't prepare the address (normally
     //       done by AddAllocatedPort) until we have these addresses.  So we
     //       wait to do that until below.
     session_->AddAllocatedPort(port, this, false);
 
@@ skipping 18 matching lines @@
 
     // Skip UDP connections to relay servers if it's disallowed.
     if (IsFlagSet(PORTALLOCATOR_DISABLE_UDP_RELAY) &&
         relay_port->proto == PROTO_UDP) {
       continue;
     }
 
     // Do not create a port if the server address family is known and does
     // not match the local IP address family.
     int server_ip_family = relay_port->address.ipaddr().family();
-    int local_ip_family = ip_.family();
+    int local_ip_family = network_->GetBestIP().family();
     if (server_ip_family != AF_UNSPEC && server_ip_family != local_ip_family) {
       LOG(LS_INFO) << "Server and local address families are not compatible. "
                    << "Server address: "
                    << relay_port->address.ipaddr().ToString()
-                   << " Local address: " << ip_.ToString();
+                   << " Local address: " << network_->GetBestIP().ToString();
       continue;
     }
 
 
     // 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 && udp_socket_) {
       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);
     } else {
-      port = TurnPort::Create(session_->network_thread(),
-                              session_->socket_factory(),
-                              network_, ip_,
-                              session_->allocator()->min_port(),
-                              session_->allocator()->max_port(),
-                              session_->username(),
-                              session_->password(),
-                              *relay_port, config.credentials, config.priority,
-                              session_->allocator()->origin());
+      port = TurnPort::Create(
+          session_->network_thread(), session_->socket_factory(), network_,
+          session_->allocator()->min_port(), session_->allocator()->max_port(),
+          session_->username(), session_->password(), *relay_port,
+          config.credentials, config.priority, session_->allocator()->origin());
     }
     RTC_DCHECK(port != NULL);
     port->SetTlsCertPolicy(config.tls_cert_policy);
     session_->AddAllocatedPort(port, this, true);
   }
 }
 
 void AllocationSequence::OnReadPacket(
     rtc::AsyncPacketSocket* socket, const char* data, size_t size,
     const rtc::SocketAddress& remote_addr,
@@ skipping 113 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