Dampening connection switch.

webrtc/p2p/base/port.cc

Index: webrtc/p2p/base/port.cc
diff --git a/webrtc/p2p/base/port.cc b/webrtc/p2p/base/port.cc
index 903f13d7a6ad360187efeb81f0a745d53c225e94..6164c3505b6aa83c0c21e8be1877f03922f87207 100644
--- a/webrtc/p2p/base/port.cc
+++ b/webrtc/p2p/base/port.cc
@@ -950,6 +950,9 @@ void Connection::OnReadPacket(
     // This is a data packet, pass it along.
     set_receiving(true);
     last_data_received_ = rtc::TimeMillis();
+    if (first_received_since_channel_weak_ == 0) {
+      first_received_since_channel_weak_ = last_data_received_;
+    }
     recv_rate_tracker_.AddSamples(size);
     SignalReadPacket(this, data, size, packet_time);
 
@@ -1188,6 +1191,9 @@ void Connection::Ping(int64_t now) {
 void Connection::ReceivedPing() {
   set_receiving(true);
   last_ping_received_ = rtc::TimeMillis();
+  if (first_received_since_channel_weak_ == 0) {
+    first_received_since_channel_weak_ = last_ping_received_;
+  }
 }
 
 void Connection::ReceivedPingResponse(int rtt) {
@@ -1203,6 +1209,9 @@ void Connection::ReceivedPingResponse(int rtt) {
   last_ping_response_received_ = rtc::TimeMillis();
   rtt_samples_++;
   rtt_ = (RTT_RATIO * rtt_ + rtt) / (RTT_RATIO + 1);
+  if (first_received_since_channel_weak_ == 0) {
+    first_received_since_channel_weak_ = last_ping_response_received_;
+  }

[pthatcher1, 2016/07/13 21:17:22]

I think this would be more clear if we had a method that both sets receiving_ to
true and updates this other variable.  For example:

void Connection::SetReceivingNow(int64_t now) {
  set_receiving(true);
  if (first_received_since_channel_weak_ == 0) {
    first_received_since_channel_weak_ == now;
  }
}


Then you can just have this in each of the three methods:
SetReceivingNow(now);


By the way, I think we should also update the other place where we call
set_receiving to be like this:

void Connection::UpdateReceiving(int64_t now) {
  set_receiving(now <= last_received() + receiving_timeout_);
}

So that it just calls:
UpdateReceiving(now)


On the other hand, if we use my idea of continuously_receiving_since(), we could
do that like so:

void Connection::set_receiving(bool value int64_t now) {
  if (value != receiving_) {
    LOG_J(LS_VERBOSE, this) << "set_receiving to " << value;
    receiving_ = value;
    if (receiving_) {
      continuously_receiving_since_ = now;
    } else {
      continuously_receiving_since_ = INT64_MAX;  // Or use rtc::optional
    }
    SignalStateChange(this);
  }
}

[honghaiz3, 2016/07/14 04:54:20]

Done. I think it does not matter what value is set when is not receiving. 
Or actually better to be 0 which is helpful when resetting the value. 

 }
 
 bool Connection::dead(int64_t now) const {