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

webrtc/p2p/base/transport.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 43 matching lines @@
 typedef std::vector<Candidate> Candidates;
 
 // For "writable" and "readable", we need to differentiate between
 // none, all, and some.
 enum TransportState {
   TRANSPORT_STATE_NONE = 0,
   TRANSPORT_STATE_SOME,
   TRANSPORT_STATE_ALL
 };
 
+// When checking transport state, we need to differentiate between
+// "readable", "writable", or "flaky" check.
+enum TransportStateType {
+  TRANSPORT_READABLE_STATE = 0,
+  TRANSPORT_WRITABLE_STATE,
+  TRANSPORT_FLAKY_STATE

[pthatcher1, 2015/06/26 19:24:03]

TRANSPORT_RECEIVING_STATE

[honghaiz3, 2015/08/05 23:56:56]

Done.

+};
+
 // Stats that we can return about the connections for a transport channel.
 // TODO(hta): Rename to ConnectionStats
 struct ConnectionInfo {
   ConnectionInfo()
       : best_connection(false),
         writable(false),
         readable(false),
         timeout(false),
         new_connection(false),
         rtt(0),
@@ skipping 91 matching lines @@
   bool any_channels_writable() const {
     return (writable_ == TRANSPORT_STATE_SOME ||
             writable_ == TRANSPORT_STATE_ALL);
   }
   bool all_channels_readable() const {
     return (readable_ == TRANSPORT_STATE_ALL);
   }
   bool all_channels_writable() const {
     return (writable_ == TRANSPORT_STATE_ALL);
   }
+  bool all_channels_flaky() const {
+    return (flaky_ == TRANSPORT_STATE_ALL);
+  }
+
   sigslot::signal1<Transport*> SignalReadableState;
   sigslot::signal1<Transport*> SignalWritableState;
+  sigslot::signal1<Transport*> SignalFlakyState;
   sigslot::signal1<Transport*> SignalCompleted;
   sigslot::signal1<Transport*> SignalFailed;
 
   // Returns whether the client has requested the channels to connect.
   bool connect_requested() const { return connect_requested_; }
 
   void SetIceRole(IceRole role);
   IceRole ice_role() const { return ice_role_; }
 
   void SetIceTiebreaker(uint64 IceTiebreaker) { tiebreaker_ = IceTiebreaker; }
@@ skipping 169 matching lines @@
     int ref_;
   };
 
   // Candidate component => ChannelMapEntry
   typedef std::map<int, ChannelMapEntry> ChannelMap;
 
   // Called when the state of a channel changes.
   void OnChannelReadableState(TransportChannel* channel);
   void OnChannelWritableState(TransportChannel* channel);
 
+  // Called when the flakiness of a channel changes.
+  void OnChannelFlakyState(TransportChannel* channel);

[pthatcher1, 2015/06/26 19:24:03]

OnChannelReceivingState

[honghaiz3, 2015/08/05 23:56:57]

Done.

+
   // Called when a channel requests signaling.
   void OnChannelRequestSignaling(TransportChannelImpl* channel);
 
   // Called when a candidate is ready from remote peer.
   void OnRemoteCandidate(const Candidate& candidate);
   // Called when a candidate is ready from channel.
   void OnChannelCandidateReady(TransportChannelImpl* channel,
                                const Candidate& candidate);
   void OnChannelRouteChange(TransportChannel* channel,
                             const Candidate& remote_candidate);
@@ skipping 10 matching lines @@
   // particular thread (s = signaling, w = worker).  The above methods post or
   // send a message to invoke this version.
   TransportChannelImpl* CreateChannel_w(int component);
   void DestroyChannel_w(int component);
   void ConnectChannels_w();
   void ResetChannels_w();
   void DestroyAllChannels_w();
   void OnRemoteCandidate_w(const Candidate& candidate);
   void OnChannelReadableState_s();
   void OnChannelWritableState_s();
+  void OnChannelFlakyState_s();
   void OnChannelRequestSignaling_s();
   void OnConnecting_s();
   void OnChannelRouteChange_s(const TransportChannel* channel,
                               const Candidate& remote_candidate);
   void OnChannelCandidatesAllocationDone_s();
 
   // Helper function that invokes the given function on every channel.
   typedef void (TransportChannelImpl::* TransportChannelFunc)();
   void CallChannels_w(TransportChannelFunc func);
 
-  // Computes the OR of the channel's read or write state (argument picks).
-  TransportState GetTransportState_s(bool read);
+  // Computes the AND and OR of the channel's read/write/flaky state
+  // (argument picks the operation).
+  TransportState GetTransportState_s(TransportStateType type);
 
   void OnChannelCandidateReady_s();
 
   void SetIceRole_w(IceRole role);
   void SetRemoteIceMode_w(IceMode mode);
   bool SetLocalTransportDescription_w(const TransportDescription& desc,
                                       ContentAction action,
                                       std::string* error_desc);
   bool SetRemoteTransportDescription_w(const TransportDescription& desc,
                                        ContentAction action,
                                        std::string* error_desc);
   bool GetStats_w(TransportStats* infos);
   bool GetRemoteCertificate_w(rtc::SSLCertificate** cert);
 
   // Sends SignalCompleted if we are now in that state.
   void MaybeCompleted_w();
 
   rtc::Thread* const signaling_thread_;
   rtc::Thread* const worker_thread_;
   const std::string content_name_;
   const std::string type_;
   PortAllocator* const allocator_;
   bool destroyed_;
   TransportState readable_;
   TransportState writable_;
+  TransportState flaky_;

[pthatcher1, 2015/06/26 19:24:03]

receiving_;

[honghaiz3, 2015/08/05 23:56:57]

Done.

   bool was_writable_;
   bool connect_requested_;
   IceRole ice_role_;
   uint64 tiebreaker_;
   TransportProtocol protocol_;
   IceMode remote_ice_mode_;
   rtc::scoped_ptr<TransportDescription> local_description_;
   rtc::scoped_ptr<TransportDescription> remote_description_;
 
   // TODO(tommi): Make sure we only use this on the worker thread.
   ChannelMap channels_;
   // Buffers the ready_candidates so that SignalCanidatesReady can
   // provide them in multiples.
   std::vector<Candidate> ready_candidates_;
   // Protects changes to channels and messages
   rtc::CriticalSection crit_;
 
   DISALLOW_COPY_AND_ASSIGN(Transport);
 };
 
 // Extract a TransportProtocol from a TransportDescription.
 TransportProtocol TransportProtocolFromDescription(
     const TransportDescription* desc);
 
 }  // namespace cricket
 
 #endif  // WEBRTC_P2P_BASE_TRANSPORT_H_