Keep on sending stun binding requests on zero-cost networks.

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.
  */
 
@@ skipping 11 matching lines @@
 
 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_TIMEOUT = 50 * 1000;    // ICE says 50 secs
 // Stop sending STUN binding requests after this amount of time
 // (in milliseconds) because the connection binding requests should keep
 // the NAT binding alive.
 const int KEEP_ALIVE_TIMEOUT = 2 * 60 * 1000;  // 2 minutes
+// This maximum deadline is used for low cost networks in order to keep the NAT
+// binding alive on a backup connection.
+const uint32_t MAX_KEEP_ALIVE_DEADLINE = 0xFFFFFFFF;
 
 // Handles a binding request sent to the STUN server.
 class StunBindingRequest : public StunRequest {
  public:
   StunBindingRequest(UDPPort* port,
                      const rtc::SocketAddress& addr,
                      uint32_t deadline)
       : port_(port), server_addr_(addr), deadline_(deadline) {
     start_time_ = rtc::Time();
   }
@@ skipping 348 matching lines @@
   }
 }
 
 void UDPPort::SendStunBindingRequest(const rtc::SocketAddress& stun_addr) {
   if (stun_addr.IsUnresolvedIP()) {
     ResolveStunAddress(stun_addr);
 
   } else if (socket_->GetState() == rtc::AsyncPacketSocket::STATE_BOUND) {
     // Check if |server_addr_| is compatible with the port's ip.
     if (IsCompatibleAddress(stun_addr)) {
-      requests_.Send(new StunBindingRequest(this, stun_addr,
-                                            rtc::Time() + KEEP_ALIVE_TIMEOUT));
+      uint32_t deadline = (network_cost() == 0)

[juberti2, 2016/02/26 01:53:41]

I don't like the |deadline| terminology - it's really confusing what the
deadline applies to. Can we call this keepalive_duration (here and above)?

Also, this needs a comment explaining what this code is trying to do.

[honghaiz3, 2016/02/26 18:46:57]

Added comments. 
Renamed it to keepalive_lifetime. I feel that duration may have the confusion
with the duration between two requests.
Also I realize that Time() may wrap around, so use a negative lifetime value to
indicate infinite lifetime.  

+                              ? MAX_KEEP_ALIVE_DEADLINE
+                              : rtc::Time() + KEEP_ALIVE_TIMEOUT;
+      requests_.Send(new StunBindingRequest(this, stun_addr, deadline));
     } else {
       // Since we can't send stun messages to the server, we should mark this
       // port ready.
       LOG(LS_WARNING) << "STUN server address is incompatible.";
       OnStunBindingOrResolveRequestFailed(stun_addr);
     }
   }
 }
 
 bool UDPPort::MaybeSetDefaultLocalAddress(rtc::SocketAddress* addr) const {
@@ skipping 93 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