Add flakiness check if there is no received packets in a certain period.

webrtc/p2p/base/p2ptransportchannel.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.
  */
 
 #include "webrtc/p2p/base/p2ptransportchannel.h"
 
 #include <set>
 #include "webrtc/p2p/base/common.h"
 #include "webrtc/p2p/base/relayport.h"  // For RELAY_PORT_TYPE.
 #include "webrtc/p2p/base/stunport.h"  // For STUN_PORT_TYPE.
 #include "webrtc/base/common.h"
 #include "webrtc/base/crc32.h"
 #include "webrtc/base/logging.h"
 #include "webrtc/base/stringencode.h"
 
 namespace {
 
 // messages for queuing up work for ourselves
 enum {
   MSG_SORT = 1,
   MSG_PING,
+  MSG_CHECK_RECEIVING
 };
 
 // When the socket is unwritable, we will use 10 Kbps (ignoring IP+UDP headers)
 // for pinging.  When the socket is writable, we will use only 1 Kbps because
 // we don't want to degrade the quality on a modem.  These numbers should work
 // well on a 28.8K modem, which is the slowest connection on which the voice
 // quality is reasonable at all.
 static const uint32 PING_PACKET_SIZE = 60 * 8;
 static const uint32 WRITABLE_DELAY = 1000 * PING_PACKET_SIZE / 1000;  // 480ms
 static const uint32 UNWRITABLE_DELAY = 1000 * PING_PACKET_SIZE / 10000;  // 50ms
 
 // If there is a current writable connection, then we will also try hard to
 // make sure it is pinged at this rate.
 static const uint32 MAX_CURRENT_WRITABLE_DELAY = 900;  // 2*WRITABLE_DELAY - bit
 
+static const int MIN_CHECK_RECEIVING_DELAY = 50;  // ms
+
 // The minimum improvement in RTT that justifies a switch.
 static const double kMinImprovement = 10;
 
 cricket::PortInterface::CandidateOrigin GetOrigin(cricket::PortInterface* port,
                                          cricket::PortInterface* origin_port) {
   if (!origin_port)
     return cricket::PortInterface::ORIGIN_MESSAGE;
   else if (port == origin_port)
     return cricket::PortInterface::ORIGIN_THIS_PORT;
   else
@@ skipping 133 matching lines @@
     waiting_for_signaling_(false),
     error_(0),
     best_connection_(NULL),
     pending_best_connection_(NULL),
     sort_dirty_(false),
     was_writable_(false),
     protocol_type_(ICEPROTO_HYBRID),
     remote_ice_mode_(ICEMODE_FULL),
     ice_role_(ICEROLE_UNKNOWN),
     tiebreaker_(0),
-    remote_candidate_generation_(0) {
+    remote_candidate_generation_(0),
+    check_receiving_delay_(MIN_CHECK_RECEIVING_DELAY * 5),
+    receiving_timeout_(MIN_CHECK_RECEIVING_DELAY * 50) {
 }
 
 P2PTransportChannel::~P2PTransportChannel() {
   ASSERT(worker_thread_ == rtc::Thread::Current());
 
   for (uint32 i = 0; i < allocator_sessions_.size(); ++i)
     delete allocator_sessions_[i];
 }
 
 // Add the allocator session to our list so that we know which sessions
@@ skipping 140 matching lines @@
     // Therefore we need to keep track of the remote ice restart so
     // newer connections are prioritized over the older.
     ++remote_candidate_generation_;
   }
 }
 
 void P2PTransportChannel::SetRemoteIceMode(IceMode mode) {
   remote_ice_mode_ = mode;
 }
 
+void P2PTransportChannel::set_receiving_timeout(int receiving_timeout_ms) {
+  receiving_timeout_ = receiving_timeout_ms;
+  check_receiving_delay_ =
+      std::max(MIN_CHECK_RECEIVING_DELAY, receiving_timeout_ / 10);
+}
+
 // Go into the state of processing candidates, and running in general
 void P2PTransportChannel::Connect() {
   ASSERT(worker_thread_ == rtc::Thread::Current());
   if (ice_ufrag_.empty() || ice_pwd_.empty()) {
     ASSERT(false);
     LOG(LS_ERROR) << "P2PTransportChannel::Connect: The ice_ufrag_ and the "
                   << "ice_pwd_ are not set.";
     return;
   }
 
   // Kick off an allocator session
   Allocate();
 
   // Start pinging as the ports come in.
   thread()->Post(this, MSG_PING);
+
+  thread()->PostDelayed(
+      check_receiving_delay_, this, MSG_CHECK_RECEIVING);
 }
 
 // A new port is available, attempt to make connections for it
 void P2PTransportChannel::OnPortReady(PortAllocatorSession *session,
                                       PortInterface* port) {
   ASSERT(worker_thread_ == rtc::Thread::Current());
 
   // Set in-effect options on the new port
   for (OptionMap::const_iterator it = options_.begin();
        it != options_.end();
@@ skipping 678 matching lines @@
   Connection* old_best_connection = best_connection_;
   best_connection_ = conn;
   if (best_connection_) {
     if (old_best_connection) {
       LOG_J(LS_INFO, this) << "Previous best connection: "
                            << old_best_connection->ToString();
     }
     LOG_J(LS_INFO, this) << "New best connection: "
                          << best_connection_->ToString();
     SignalRouteChange(this, best_connection_->remote_candidate());
+    // When it just switched to a best connection, set receiving to true.
+    set_receiving(true);
   } else {
     LOG_J(LS_INFO, this) << "No best connection";
   }
 }
 
 void P2PTransportChannel::UpdateChannelState() {
   // The Handle* functions already set the writable state.  We'll just double-
   // check it here.
   bool writable = ((best_connection_ != NULL)  &&
       (best_connection_->write_state() ==
@@ skipping 61 matching lines @@
 
 // Handle any queued up requests
 void P2PTransportChannel::OnMessage(rtc::Message *pmsg) {
   switch (pmsg->message_id) {
     case MSG_SORT:
       OnSort();
       break;
     case MSG_PING:
       OnPing();
       break;
+    case MSG_CHECK_RECEIVING:
+      OnCheckReceiving();
+      break;
     default:
       ASSERT(false);
       break;
   }
 }
 
 // Handle queued up sort request
 void P2PTransportChannel::OnSort() {
   // Resort the connections based on the new statistics.
   SortConnections();
 }
 
 // Handle queued up ping request
 void P2PTransportChannel::OnPing() {
   // Make sure the states of the connections are up-to-date (since this affects
   // which ones are pingable).
   UpdateConnectionStates();
 
   // Find the oldest pingable connection and have it do a ping.
   Connection* conn = FindNextPingableConnection();
   if (conn)
     PingConnection(conn);
 
   // Post ourselves a message to perform the next ping.
   uint32 delay = writable() ? WRITABLE_DELAY : UNWRITABLE_DELAY;
   thread()->PostDelayed(delay, this, MSG_PING);
 }
 
+void P2PTransportChannel::OnCheckReceiving() {
+  // Check receiving only if the best connection has received data packets
+  // because we want to detect not receiving any packets only after the media
+  // have started flowing.
+  if (best_connection_ && best_connection_->recv_total_bytes() > 0) {
+    bool receiving = rtc::Time() <=
+        best_connection_->last_received() + receiving_timeout_;
+    set_receiving(receiving);
+  }
+
+  thread()->PostDelayed(check_receiving_delay_, this, MSG_CHECK_RECEIVING);
+}
+
 // Is the connection in a state for us to even consider pinging the other side?
 // We consider a connection pingable even if it's not connected because that's
 // how a TCP connection is kicked into reconnecting on the active side.
 bool P2PTransportChannel::IsPingable(Connection* conn) {
   const Candidate& remote = conn->remote_candidate();
   // We should never get this far with an empty remote ufrag.
   ASSERT(!remote.username().empty());
   if (remote.username().empty() || remote.password().empty()) {
     // If we don't have an ICE ufrag and pwd, there's no way we can ping.
     return false;
@@ skipping 182 matching lines @@
   SignalReadPacket(this, data, len, packet_time, 0);
 }
 
 void P2PTransportChannel::OnReadyToSend(Connection* connection) {
   if (connection == best_connection_ && writable()) {
     SignalReadyToSend(this);
   }
 }
 
 }  // namespace cricket