Dampening connection switch.

webrtc/p2p/base/port.cc

 /*
  *  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 932 matching lines @@
 void Connection::OnReadPacket(
   const char* data, size_t size, const rtc::PacketTime& packet_time) {
   std::unique_ptr<IceMessage> msg;
   std::string remote_ufrag;
   const rtc::SocketAddress& addr(remote_candidate_.address());
   if (!port_->GetStunMessage(data, size, addr, &msg, &remote_ufrag)) {
     // The packet did not parse as a valid STUN message
     // 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);
 
     // If timed out sending writability checks, start up again
     if (!pruned_ && (write_state_ == STATE_WRITE_TIMEOUT)) {
       LOG(LS_WARNING) << "Received a data packet on a timed-out Connection. "
                       << "Resetting state to STATE_WRITE_INIT.";
       set_write_state(STATE_WRITE_INIT);
     }
   } else if (!msg) {
@@ skipping 218 matching lines @@
   LOG_J(LS_VERBOSE, this) << "Sending STUN ping "
                           << ", id=" << rtc::hex_encode(req->id());
   requests_.Send(req);
   state_ = STATE_INPROGRESS;
   num_pings_sent_++;
 }
 
 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) {
   // We've already validated that this is a STUN binding response with
   // the correct local and remote username for this connection.
   // So if we're not already, become writable. We may be bringing a pruned
   // connection back to life, but if we don't really want it, we can always
   // prune it again.
   set_receiving(true);
   set_write_state(STATE_WRITABLE);
   set_state(STATE_SUCCEEDED);
   pings_since_last_response_.clear();
   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 {
   if (last_received() > 0) {
     // If it has ever received anything, we keep it alive until it hasn't
     // received anything for DEAD_CONNECTION_RECEIVE_TIMEOUT. This covers the
     // normal case of a successfully used connection that stops working. This
     // also allows a remote peer to continue pinging over a locally inactive
     // (pruned) connection.
     return (now > (last_received() + DEAD_CONNECTION_RECEIVE_TIMEOUT));
@@ skipping 313 matching lines @@
     ASSERT(sent < 0);
     error_ = port_->GetError();
     stats_.sent_discarded_packets++;
   } else {
     send_rate_tracker_.AddSamples(sent);
   }
   return sent;
 }
 
 }  // namespace cricket