Fixing problems with ICE candidate pair prioritization.

webrtc/p2p/base/port.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 71 matching lines @@
 
 enum IcePriorityValue {
   // The reason we are choosing Relay preference 2 is because, we can run
   // Relay from client to server on UDP/TCP/TLS. To distinguish the transport
   // protocol, we prefer UDP over TCP over TLS.
   // For UDP ICE_TYPE_PREFERENCE_RELAY will be 2.
   // For TCP ICE_TYPE_PREFERENCE_RELAY will be 1.
   // For TLS ICE_TYPE_PREFERENCE_RELAY will be 0.
   // Check turnport.cc for setting these values.
   ICE_TYPE_PREFERENCE_RELAY = 2,
+  ICE_TYPE_PREFERENCE_PRFLX_TCP = 80,
   ICE_TYPE_PREFERENCE_HOST_TCP = 90,
   ICE_TYPE_PREFERENCE_SRFLX = 100,
   ICE_TYPE_PREFERENCE_PRFLX = 110,
   ICE_TYPE_PREFERENCE_HOST = 126
 };
 
 const char* ProtoToString(ProtocolType proto);
 bool StringToProto(const char* value, ProtocolType* proto);
 
 struct ProtocolAddress {
@@ skipping 544 matching lines @@
 
   Port* port_;
   size_t local_candidate_index_;
   Candidate remote_candidate_;
 
   ConnectionInfo stats_;
   rtc::RateTracker recv_rate_tracker_;
   rtc::RateTracker send_rate_tracker_;
 
  private:
+  // Update the local candidate based on the mapped address attribute.
+  // If the local candidate changed, fires SignalStateChange.
+  void MaybeUpdateLocalCandidate(ConnectionRequest* request,
+                                 StunMessage* response);
+
   WriteState write_state_;
   bool receiving_;
   bool connected_;
   bool pruned_;
   // By default |use_candidate_attr_| flag will be true,
   // as we will be using aggressive nomination.
   // But when peer is ice-lite, this flag "must" be initialized to false and
   // turn on when connection becomes "best connection".
   bool use_candidate_attr_;
   // Used by the controlling side to indicate that this connection will be
@@ skipping 14 matching lines @@
   int rtt_;
   int rtt_samples_ = 0;
   int64_t last_ping_sent_;      // last time we sent a ping to the other side
   int64_t last_ping_received_;  // last time we received a ping from the other
                                 // side
   int64_t last_data_received_;
   int64_t last_ping_response_received_;
   int64_t receiving_unchanged_since_ = 0;
   std::vector<SentPing> pings_since_last_response_;
 
-  void MaybeAddPrflxCandidate(ConnectionRequest* request,
-                              StunMessage* response);
-
   bool reported_;
   State state_;
   // Time duration to switch from receiving to not receiving.
   int receiving_timeout_;
   int64_t time_created_ms_;
   int num_pings_sent_ = 0;
 
   friend class Port;
   friend class ConnectionRequest;
 };
 
 // ProxyConnection defers all the interesting work to the port.
 class ProxyConnection : public Connection {
  public:
   ProxyConnection(Port* port, size_t index, const Candidate& remote_candidate);
 
   int Send(const void* data,
            size_t size,
            const rtc::PacketOptions& options) override;
   int GetError() override { return error_; }
 
  private:
   int error_ = 0;
 };
 
 }  // namespace cricket
 
 #endif  // WEBRTC_P2P_BASE_PORT_H_