Dampening connection switch.

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 572 matching lines @@
                                                  int generation);
 
   // If |remote_candidate_| is peer reflexive and is equivalent to
   // |new_candidate| except the type, update |remote_candidate_| to
   // |new_candidate|.
   void MaybeUpdatePeerReflexiveCandidate(const Candidate& new_candidate);
 
   // Returns the last received time of any data, stun request, or stun
   // response in milliseconds
   int64_t last_received() const;
+  // Returns the first time since which the connection has been in receiving
+  // state.

[pthatcher1, 2016/07/14 18:01:44]

I think it should be more like the time at which we transitioned from not
receiving -> receiving and haven't transitioned to not receiving since.

[honghaiz3, 2016/07/14 23:15:01]

Done.

+  int64_t continuously_receiving_since() const {
+    return continuously_receiving_since_;
+  }
+
+  void reset_continuously_receiving_since(int64_t now) {
+    if (continuously_receiving_since_ > 0) {
+      continuously_receiving_since_ = now;
+    }
+  }
 
   bool stable(int64_t now) const;
 
  protected:
   enum { MSG_DELETE = 0, MSG_FIRST_AVAILABLE };
 
   // Constructs a new connection to the given remote port.
   Connection(Port* port, size_t index, const Candidate& candidate);
 
   // Called back when StunRequestManager has a stun packet to send
   void OnSendStunPacket(const void* data, size_t size, StunRequest* req);
 
   // Callbacks from ConnectionRequest
   virtual void OnConnectionRequestResponse(ConnectionRequest* req,
                                            StunMessage* response);
   void OnConnectionRequestErrorResponse(ConnectionRequest* req,
                                         StunMessage* response);
   void OnConnectionRequestTimeout(ConnectionRequest* req);
   void OnConnectionRequestSent(ConnectionRequest* req);
 
   bool rtt_converged() const;
 
   // If the response is not received within 2 * RTT, the response is assumed to
   // be missing.
   bool missing_responses(int64_t now) const;
 
   // Changes the state and signals if necessary.
   void set_write_state(WriteState value);
-  void set_receiving(bool value);
+  void UpdateReceiving(int64_t now);
   void set_state(State state);
   void set_connected(bool value);
 
   void OnMessage(rtc::Message *pmsg);
 
   Port* port_;
   size_t local_candidate_index_;
   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_;
   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 continuously_receiving_since_ = 0;

[pthatcher1, 2016/07/14 18:01:44]

Well, that makes it sounds like we've been continuously receiving forever. 
Perhaps using an rtc::optional would be more careful not to get confused about
that.  Or make it 7FFF FFFF.

[honghaiz3, 2016/07/14 23:15:01]

As I said, the value should not be used at all if the connection is not in
receiving state. So it does not matter what value we put there and it does not
worth using an optional here. 
What about -1?

   std::vector<SentPing> pings_since_last_response_;
 
   rtc::RateTracker recv_rate_tracker_;
   rtc::RateTracker send_rate_tracker_;
 
   ConnectionInfo stats_;
 
  private:
   void MaybeAddPrflxCandidate(ConnectionRequest* request,
                               StunMessage* response);
@@ skipping 19 matching lines @@
            const rtc::PacketOptions& options) override;
   int GetError() override { return error_; }
 
  private:
   int error_ = 0;
 };
 
 }  // namespace cricket
 
 #endif  // WEBRTC_P2P_BASE_PORT_H_