Update the type and cost of existing networks if its type is found later by network monitor

webrtc/p2p/base/stunport.h

 /*
  *  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.
  */
 
 #ifndef WEBRTC_P2P_BASE_STUNPORT_H_
 #define WEBRTC_P2P_BASE_STUNPORT_H_
 
 #include <memory>
 #include <string>
 
 #include "webrtc/p2p/base/port.h"
 #include "webrtc/p2p/base/stunrequest.h"
 #include "webrtc/base/asyncpacketsocket.h"
 
 // TODO(mallinath) - Rename stunport.cc|h to udpport.cc|h.
 namespace rtc {
 class AsyncResolver;
 class SignalThread;
 }
 
 namespace cricket {
 
+// Lifetime chosen for STUN ports on low-cost networks.
+static const int INFINITE_LIFETIME = -1;
+// Lifetime for STUN ports on high-cost networks: 2 minutes
+static const int HIGH_COST_PORT_KEEPALIVE_LIFETIME = 2 * 60 * 1000;
+
 // Communicates using the address on the outside of a NAT.
 class UDPPort : public Port {
  public:
   static UDPPort* Create(rtc::Thread* thread,
                          rtc::PacketSocketFactory* factory,
                          rtc::Network* network,
                          rtc::AsyncPacketSocket* socket,
                          const std::string& username,
                          const std::string& password,
                          const std::string& origin,
@@ skipping 99 matching lines @@
           const std::string& origin,
           bool emit_local_for_anyaddress);
 
   bool Init();
 
   virtual int SendTo(const void* data, size_t size,
                      const rtc::SocketAddress& addr,
                      const rtc::PacketOptions& options,
                      bool payload);
 
+  virtual void UpdateNetworkCost();
+
   void OnLocalAddressReady(rtc::AsyncPacketSocket* socket,
                            const rtc::SocketAddress& address);
   void OnReadPacket(rtc::AsyncPacketSocket* socket,
                     const char* data, size_t size,
                     const rtc::SocketAddress& remote_addr,
                     const rtc::PacketTime& packet_time);
 
   void OnSentPacket(rtc::AsyncPacketSocket* socket,
                     const rtc::SentPacket& sent_packet);
 
@@ skipping 54 matching lines @@
 
   // Sends STUN requests to the server.
   void OnSendPacket(const void* data, size_t size, StunRequest* req);
 
   // TODO(mallinaht) - Move this up to cricket::Port when SignalAddressReady is
   // changed to SignalPortReady.
   void MaybeSetPortCompleteOrError();
 
   bool HasCandidateWithAddress(const rtc::SocketAddress& addr) const;
 
+  // If this is a low-cost network, it will keep on sending STUN binding
+  // requests indefinitely to keep the NAT binding alive. Otherwise, stop
+  // sending STUN binding requests after HIGH_COST_PORT_KEEPALIVE_LIFETIME.
+  int GetStunKeepaliveLifetime() {
+    return (network_cost() >= rtc::kNetworkCostHigh)
+               ? HIGH_COST_PORT_KEEPALIVE_LIFETIME
+               : INFINITE_LIFETIME;
+  }
+
   ServerAddresses server_addresses_;
   ServerAddresses bind_request_succeeded_servers_;
   ServerAddresses bind_request_failed_servers_;
   StunRequestManager requests_;
   rtc::AsyncPacketSocket* socket_;
   int error_;
   std::unique_ptr<AddressResolver> resolver_;
   bool ready_;
   int stun_keepalive_delay_;
-  int stun_keepalive_lifetime_;
+  int stun_keepalive_lifetime_ = INFINITE_LIFETIME;
 
   // This is true by default and false when
   // PORTALLOCATOR_DISABLE_DEFAULT_LOCAL_CANDIDATE is specified.
   bool emit_local_for_anyaddress_;
 
   friend class StunBindingRequest;
 };
 
 class StunPort : public UDPPort {
  public:
@@ skipping 47 matching lines @@
                 false) {
     // UDPPort will set these to local udp, updating these to STUN.
     set_type(STUN_PORT_TYPE);
     set_server_addresses(servers);
   }
 };
 
 }  // namespace cricket
 
 #endif  // WEBRTC_P2P_BASE_STUNPORT_H_