Prepare for ICE-renomination

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 394 matching lines @@
   friend class Connection;
 };
 
 // Represents a communication link between a port on the local client and a
 // port on the remote client.
 class Connection : public CandidatePairInterface,
                    public rtc::MessageHandler,
                    public sigslot::has_slots<> {
  public:
   struct SentPing {
-    SentPing(const std::string id, int64_t sent_time)
-        : id(id), sent_time(sent_time) {}
+    SentPing(const std::string id, int64_t sent_time, int nomination_value)
+        : id(id), sent_time(sent_time), nomination_value(nomination_value) {}
 
     std::string id;
     int64_t sent_time;
+    int nomination_value;
   };
 
   // States are from RFC 5245. http://tools.ietf.org/html/rfc5245#section-5.7.4
   enum State {
     STATE_WAITING = 0,  // Check has not been performed, Waiting pair on CL.
     STATE_INPROGRESS,   // Check has been sent, transaction is in progress.
     STATE_SUCCEEDED,    // Check already done, produced a successful result.
     STATE_FAILED        // Check for this connection failed.
   };
 
@@ skipping 69 matching lines @@
   // Called when a connection is determined to be no longer useful to us.  We
   // still keep it around in case the other side wants to use it.  But we can
   // safely stop pinging on it and we can allow it to time out if the other
   // side stops using it as well.
   bool pruned() const { return pruned_; }
   void Prune();
 
   bool use_candidate_attr() const { return use_candidate_attr_; }
   void set_use_candidate_attr(bool enable);
 
-  bool nominated() const { return nominated_; }
-  void set_nominated(bool nominated) { nominated_ = nominated; }
+  int nominating_value() const { return nominating_value_; }
+  void set_nominating_value(int value) {
+    if (value > nominating_value_) {
+      nomination_acknowledged_ = false;
+    }
+    // A connection may be the selected one earlier, but be switched later,
+    // so its |nominating_value_| may go to 0.
+    nominating_value_ = value;
+  }
+  bool nomination_acknowledged() const { return nomination_acknowledged_; }
+
+  int nominated_value() const { return nominated_value_; }
+  void set_nominated_value(int nominated_value) {
+    // We don't un-nominate a connection, so we will keep the maximum
+    // nominated value.
+    if (nominated_value > nominated_value_) {
+      nominated_value_ = nominated_value;
+    }
+  }
 
   void set_remote_ice_mode(IceMode mode) {
     remote_ice_mode_ = mode;
   }
 
   void set_receiving_timeout(int64_t receiving_timeout_ms) {
     receiving_timeout_ = receiving_timeout_ms;
   }
 
   // Makes the connection go away.
   void Destroy();
 
   // Makes the connection go away, in a failed state.
   void FailAndDestroy();
 
   // Prunes the connection and sets its state to STATE_FAILED,
   // It will not be used or send pings although it can still receive packets.
   void FailAndPrune();
 
   // Checks that the state of this connection is up-to-date.  The argument is
   // the current time, which is compared against various timeouts.
   void UpdateState(int64_t now);
 
   // Called when this connection should try checking writability again.
   int64_t last_ping_sent() const { return last_ping_sent_; }
   void Ping(int64_t now);
-  void ReceivedPingResponse(int rtt);
+  void ReceivedPingResponse(int rtt, const std::string& request_id);
   int64_t last_ping_response_received() const {
     return last_ping_response_received_;
   }
 
   // Called whenever a valid ping is received on this connection.  This is
   // public because the connection intercepts the first ping for us.
   int64_t last_ping_received() const { return last_ping_received_; }
   void ReceivedPing();
   // Handles the binding request; sends a response if this is a valid request.
   void HandleBindingRequest(IceMessage* msg);
@@ skipping 85 matching lines @@
   Candidate remote_candidate_;
   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_;
-  // Whether this connection has been nominated by the controlling side via
-  // the use_candidate attribute.
-  bool nominated_;
+  // Used by the controlling side to indicate that this connection will be
+  // selected for transmission if the peer supports ICE-renomination if this
+  // value is positive. A larger-value indicates that a connection is nominated
+  // later and should be selected by the controlled side with higher precedence.
+  // It should start from zero to indicate not nominating this connection yet.
+  int nominating_value_ = 0;
+  // Whether the current nominating_value has been acknowledged by the peer.
+  // If yes, no nomination-value attribute is needed in the ping request on the
+  // same connection.
+  bool nomination_acknowledged_;
+  // Used by the controlled side to remember the nomination value received from
+  // the controlling side. When the peer does not support ICE re-nomination,
+  // its value will be 1 if the connection is nominated.
+  int nominated_value_ = 0;
+
   IceMode remote_ice_mode_;
   StunRequestManager requests_;
   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;
@@ skipping 29 matching lines @@
            const rtc::PacketOptions& options) override;
   int GetError() override { return error_; }
 
  private:
   int error_ = 0;
 };
 
 }  // namespace cricket
 
 #endif  // WEBRTC_P2P_BASE_PORT_H_