Ping the premier connection on each network with higher priority.

webrtc/p2p/base/p2ptransportchannel.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.
  */
 
@@ skipping 25 matching lines @@
 #include "webrtc/base/asyncpacketsocket.h"
 #include "webrtc/base/sigslot.h"
 
 namespace cricket {
 
 // Enum for UMA metrics, used to record whether the channel is
 // connected/connecting/disconnected when ICE restart happens.
 enum class IceRestartState { CONNECTING, CONNECTED, DISCONNECTED, MAX_VALUE };
 
 extern const int WEAK_PING_INTERVAL;
-extern const int STABILIZING_WRITABLE_CONNECTION_PING_INTERVAL;
-extern const int STABLE_WRITABLE_CONNECTION_PING_INTERVAL;
+extern const int WEAK_OR_STABILIZING_WRITABLE_CONNECTION_PING_INTERVAL;
+extern const int STRONG_AND_STABLE_WRITABLE_CONNECTION_PING_INTERVAL;
 static const int MIN_PINGS_AT_WEAK_PING_INTERVAL = 3;
 
 // Adds the port on which the candidate originated.
 class RemoteCandidate : public Candidate {
  public:
   RemoteCandidate(const Candidate& c, PortInterface* origin_port)
       : Candidate(c), origin_port_(origin_port) {}
 
   PortInterface* origin_port() { return origin_port_; }
 
@@ skipping 196 matching lines @@
   bool CreateConnection(PortInterface* port,
                         const Candidate& remote_candidate,
                         PortInterface* origin_port);
   bool FindConnection(cricket::Connection* connection) const;
 
   uint32_t GetRemoteCandidateGeneration(const Candidate& candidate);
   bool IsDuplicateRemoteCandidate(const Candidate& candidate);
   void RememberRemoteCandidate(const Candidate& remote_candidate,
                                PortInterface* origin_port);
   bool IsPingable(const Connection* conn, int64_t now) const;
-  bool IsSelectedConnectionPingable(int64_t now);
+  // Whether a writable connection is past its ping interval and needs to be
+  // pinged again.
+  bool WritableConnectionPastPingInterval(const Connection* conn,
+                                          int64_t now) const;
   int CalculateActiveWritablePingInterval(const Connection* conn,
                                           int64_t now) const;
   void PingConnection(Connection* conn);
   void AddAllocatorSession(std::unique_ptr<PortAllocatorSession> session);
   void AddConnection(Connection* connection);
 
   void OnPortReady(PortAllocatorSession *session, PortInterface* port);
   void OnPortsPruned(PortAllocatorSession* session,
                      const std::vector<PortInterface*>& ports);
   void OnCandidatesReady(PortAllocatorSession *session,
@@ skipping 35 matching lines @@
   // Returns true if we should switch to the new connection.
   // sets |missed_receiving_unchanged_threshold| to true if either
   // the selected connection or the new connection missed its
   // receiving-unchanged-threshold.
   bool ShouldSwitchSelectedConnection(
       Connection* new_connection,
       bool* missed_receiving_unchanged_threshold) const;
   // Returns true if the new_connection is selected for transmission.
   bool MaybeSwitchSelectedConnection(Connection* new_connection,
                                      const std::string& reason);
-
+  // Gets the best connection for each network.
+  std::map<rtc::Network*, Connection*> GetBestConnectionByNetwork() const;
+  std::vector<Connection*> GetBestWritableConnectionPerNetwork() const;
   void PruneConnections();
   bool IsBackupConnection(const Connection* conn) const;
 
-  Connection* FindConnectionToPing(int64_t now);
   Connection* FindOldestConnectionNeedingTriggeredCheck(int64_t now);
   // Between |conn1| and |conn2|, this function returns the one which should
   // be pinged first.
-  Connection* SelectMostPingableConnection(Connection* conn1,
-                                           Connection* conn2);
+  Connection* MorePingable(Connection* conn1, Connection* conn2);
   // Select the connection which is Relay/Relay. If both of them are,
   // UDP relay protocol takes precedence.
   Connection* MostLikelyToWork(Connection* conn1, Connection* conn2);
   // Compare the last_ping_sent time and return the one least recently pinged.
   Connection* LeastRecentlyPinged(Connection* conn1, Connection* conn2);
 
   // Returns the latest remote ICE parameters or nullptr if there are no remote
   // ICE parameters yet.
   IceParameters* remote_ice() {
     return remote_ice_parameters_.empty() ? nullptr
@@ skipping 60 matching lines @@
   uint32_t nomination_ = 0;
 
   webrtc::MetricsObserverInterface* metrics_observer_ = nullptr;
 
   RTC_DISALLOW_COPY_AND_ASSIGN(P2PTransportChannel);
 };
 
 }  // namespace cricket
 
 #endif  // WEBRTC_P2P_BASE_P2PTRANSPORTCHANNEL_H_