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

webrtc/p2p/base/transport.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 17 matching lines @@
   MSG_READSTATE,
   MSG_WRITESTATE,
   MSG_REQUESTSIGNALING,
   MSG_CANDIDATEREADY,
   MSG_ROUTECHANGE,
   MSG_CONNECTING,
   MSG_CANDIDATEALLOCATIONCOMPLETE,
   MSG_ROLECONFLICT,
   MSG_COMPLETED,
   MSG_FAILED,
+  MSG_RECEIVINGSTATE,
 };
 
 struct ChannelParams : public rtc::MessageData {
   ChannelParams() : channel(NULL), candidate(NULL) {}
   explicit ChannelParams(int component)
       : component(component), channel(NULL), candidate(NULL) {}
   explicit ChannelParams(Candidate* candidate)
       : channel(NULL), candidate(candidate) {
   }
 
@@ skipping 73 matching lines @@
                      const std::string& type,
                      PortAllocator* allocator)
   : signaling_thread_(signaling_thread),
     worker_thread_(worker_thread),
     content_name_(content_name),
     type_(type),
     allocator_(allocator),
     destroyed_(false),
     readable_(TRANSPORT_STATE_NONE),
     writable_(TRANSPORT_STATE_NONE),
+    receiving_(TRANSPORT_STATE_NONE),
     was_writable_(false),
     connect_requested_(false),
     ice_role_(ICEROLE_UNKNOWN),
     tiebreaker_(0),
     protocol_(ICEPROTO_HYBRID),
     remote_ice_mode_(ICEMODE_FULL) {
 }
 
 Transport::~Transport() {
   ASSERT(signaling_thread_->IsCurrent());
@@ skipping 94 matching lines @@
   // below Apply**Description_w calls can fail.
   if (local_description_)
     ApplyLocalTransportDescription_w(impl, NULL);
   if (remote_description_)
     ApplyRemoteTransportDescription_w(impl, NULL);
   if (local_description_ && remote_description_)
     ApplyNegotiatedTransportDescription_w(impl, NULL);
 
   impl->SignalReadableState.connect(this, &Transport::OnChannelReadableState);
   impl->SignalWritableState.connect(this, &Transport::OnChannelWritableState);
+  impl->SignalReceivingState.connect(this, &Transport::OnChannelReceivingState);
   impl->SignalRequestSignaling.connect(
       this, &Transport::OnChannelRequestSignaling);
   impl->SignalCandidateReady.connect(this, &Transport::OnChannelCandidateReady);
   impl->SignalRouteChange.connect(this, &Transport::OnChannelRouteChange);
   impl->SignalCandidatesAllocationDone.connect(
       this, &Transport::OnChannelCandidatesAllocationDone);
   impl->SignalRoleConflict.connect(this, &Transport::OnRoleConflict);
   impl->SignalConnectionRemoved.connect(
       this, &Transport::OnChannelConnectionRemoved);
 
@@ skipping 239 matching lines @@
   }
 }
 
 void Transport::OnChannelReadableState(TransportChannel* channel) {
   ASSERT(worker_thread()->IsCurrent());
   signaling_thread()->Post(this, MSG_READSTATE, NULL);
 }
 
 void Transport::OnChannelReadableState_s() {
   ASSERT(signaling_thread()->IsCurrent());
-  TransportState readable = GetTransportState_s(true);
+  TransportState readable = GetTransportState_s(TRANSPORT_READABLE_STATE);
   if (readable_ != readable) {
     readable_ = readable;
     SignalReadableState(this);
   }
 }
 
 void Transport::OnChannelWritableState(TransportChannel* channel) {
   ASSERT(worker_thread()->IsCurrent());
   signaling_thread()->Post(this, MSG_WRITESTATE, NULL);
 
   MaybeCompleted_w();
 }
 
 void Transport::OnChannelWritableState_s() {
   ASSERT(signaling_thread()->IsCurrent());
-  TransportState writable = GetTransportState_s(false);
+  TransportState writable = GetTransportState_s(TRANSPORT_WRITABLE_STATE);
   if (writable_ != writable) {
     was_writable_ = (writable_ == TRANSPORT_STATE_ALL);
     writable_ = writable;
     SignalWritableState(this);
   }
 }
 
-TransportState Transport::GetTransportState_s(bool read) {
+void Transport::OnChannelReceivingState(TransportChannel* channel) {
+  ASSERT(worker_thread()->IsCurrent());
+  signaling_thread()->Post(this, MSG_RECEIVINGSTATE);
+}
+
+void Transport::OnChannelReceivingState_s() {
+  ASSERT(signaling_thread()->IsCurrent());
+  TransportState receiving = GetTransportState_s(TRANSPORT_RECEIVING_STATE);
+  if (receiving_ != receiving) {
+    receiving_ = receiving;
+    SignalReceivingState(this);
+  }
+}
+
+TransportState Transport::GetTransportState_s(TransportStateType state_type) {
   ASSERT(signaling_thread()->IsCurrent());
 
   rtc::CritScope cs(&crit_);
   bool any = false;
   bool all = !channels_.empty();
   for (const auto iter : channels_) {
-    bool b = (read ? iter.second->readable() :
-                     iter.second->writable());
+    bool b = false;
+    switch (state_type) {
+      case TRANSPORT_READABLE_STATE:
+        b = iter.second->readable();
+        break;
+      case TRANSPORT_WRITABLE_STATE:
+        b = iter.second->writable();
+        break;
+      case TRANSPORT_RECEIVING_STATE:
+        b = iter.second->receiving();
+        break;
+      default:
+        ASSERT(false);
+    }
     any |= b;
     all &=  b;
   }
 
   if (all) {
     return TRANSPORT_STATE_ALL;
   } else if (any) {
     return TRANSPORT_STATE_SOME;
   }
 
@@ skipping 346 matching lines @@
       break;
     case MSG_CONNECTING:
       OnConnecting_s();
       break;
     case MSG_READSTATE:
       OnChannelReadableState_s();
       break;
     case MSG_WRITESTATE:
       OnChannelWritableState_s();
       break;
+    case MSG_RECEIVINGSTATE:
+      OnChannelReceivingState_s();
+      break;
     case MSG_REQUESTSIGNALING:
       OnChannelRequestSignaling_s();
       break;
     case MSG_CANDIDATEREADY:
       OnChannelCandidateReady_s();
       break;
     case MSG_ROUTECHANGE: {
         ChannelParams* params = static_cast<ChannelParams*>(msg->pdata);
         OnChannelRouteChange_s(params->channel, *params->candidate);
         delete params;
@@ skipping 20 matching lines @@
     const TransportDescription* desc) {
   ASSERT(desc != NULL);
   if (desc->transport_type == NS_JINGLE_ICE_UDP) {
     return (desc->HasOption(ICE_OPTION_GICE)) ?
         ICEPROTO_HYBRID : ICEPROTO_RFC5245;
   }
   return ICEPROTO_GOOGLE;
 }
 
 }  // namespace cricket