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

talk/app/webrtc/webrtcsession.h

 /*
  * libjingle
  * Copyright 2012 Google Inc.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions are met:
  *
  *  1. Redistributions of source code must retain the above copyright notice,
  *     this list of conditions and the following disclaimer.
  *  2. Redistributions in binary form must reproduce the above copyright notice,
@@ skipping 66 matching lines @@
 extern const char kDtlsSetupFailureRtcp[];
 // Maximum number of received video streams that will be processed by webrtc
 // even if they are not signalled beforehand.
 extern const int kMaxUnsignalledRecvStreams;
 
 // ICE state callback interface.
 class IceObserver {
  public:
   IceObserver() {}
   // Called any time the IceConnectionState changes
+  // TODO(honghaiz): Change the name to OnIceConnectionStateChange so as to
+  // conform to the w3c standard.

[pthatcher1, 2015/07/06 22:04:47]

Just one TODO is sufficient.  You can remove this one.

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

I kept this one and removed the other one because this is the definition of the
interface. 

   virtual void OnIceConnectionChange(
       PeerConnectionInterface::IceConnectionState new_state) {}
   // Called any time the IceGatheringState changes
   virtual void OnIceGatheringChange(
       PeerConnectionInterface::IceGatheringState new_state) {}
   // New Ice candidate have been found.
   virtual void OnIceCandidate(const IceCandidateInterface* candidate) = 0;
   // All Ice candidates have been found.
   // TODO(bemasc): Remove this once callers transition to OnIceGatheringChange.
   // (via PeerConnectionObserver)
   virtual void OnIceComplete() {}
 
+  // Called anytime when all ICE transport channels started not receiving
+  // packets or at least one channel changes back.

[pthatcher1, 2015/07/06 22:04:47]

Might be more clear with something like:

"Called with receiving=true when packets are first received, then called with
receiving=false when no packets are received for a certain time period, and then
called whenever the state changes between receiving and not receiving."

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

Maybe enough just with the last sentence. 

+  virtual void OnIceConnectionReceivingChange(bool receiving) {}
+
  protected:
   ~IceObserver() {}
 
  private:
   DISALLOW_COPY_AND_ASSIGN(IceObserver);
 };
 
 class WebRtcSession : public cricket::BaseSession,
                       public AudioProviderInterface,
                       public DataChannelFactory,
@@ skipping 182 matching lines @@
   // Transport related callbacks, override from cricket::BaseSession.
   virtual void OnTransportRequestSignaling(cricket::Transport* transport);
   virtual void OnTransportConnecting(cricket::Transport* transport);
   virtual void OnTransportWritable(cricket::Transport* transport);
   virtual void OnTransportCompleted(cricket::Transport* transport);
   virtual void OnTransportFailed(cricket::Transport* transport);
   virtual void OnTransportProxyCandidatesReady(
       cricket::TransportProxy* proxy,
       const cricket::Candidates& candidates);
   virtual void OnCandidatesAllocationDone();
+  void OnTransportReceiving(cricket::Transport* transport) override;
 
   // Enables media channels to allow sending of media.
   void EnableChannels();
   // Creates a JsepIceCandidate and adds it to the local session description
   // and notify observers. Called when a new local candidate have been found.
   void ProcessNewLocalCandidate(const std::string& content_name,
                                 const cricket::Candidates& candidates);
   // Returns the media index for a local ice candidate given the content name.
   // Returns false if the local session description does not have a media
   // content called  |content_name|.
@@ skipping 24 matching lines @@
   void CopySavedCandidates(SessionDescriptionInterface* dest_desc);
 
   // Listens to SCTP CONTROL messages on unused SIDs and process them as OPEN
   // messages.
   void OnDataChannelMessageReceived(cricket::DataChannel* channel,
                                     const cricket::ReceiveDataParams& params,
                                     const rtc::Buffer& payload);
 
   std::string BadStateErrMsg(State state);
   void SetIceConnectionState(PeerConnectionInterface::IceConnectionState state);
+  void SetIceConnectionReceiving(bool receiving);
 
   bool ValidateBundleSettings(const cricket::SessionDescription* desc);
   bool HasRtcpMuxEnabled(const cricket::ContentInfo* content);
   // Below methods are helper methods which verifies SDP.
   bool ValidateSessionDescription(const SessionDescriptionInterface* sdesc,
                                   cricket::ContentSource source,
                                   std::string* err_desc);
 
   // Check if a call to SetLocalDescription is acceptable with |action|.
   bool ExpectSetLocalDescription(Action action);
@@ skipping 19 matching lines @@
 
   void ReportNegotiatedCiphers(const cricket::TransportStats& stats);
 
   rtc::scoped_ptr<cricket::VoiceChannel> voice_channel_;
   rtc::scoped_ptr<cricket::VideoChannel> video_channel_;
   rtc::scoped_ptr<cricket::DataChannel> data_channel_;
   cricket::ChannelManager* channel_manager_;
   MediaStreamSignaling* mediastream_signaling_;
   IceObserver* ice_observer_;
   PeerConnectionInterface::IceConnectionState ice_connection_state_;
+  bool ice_connection_receiving_;
   rtc::scoped_ptr<SessionDescriptionInterface> local_desc_;
   rtc::scoped_ptr<SessionDescriptionInterface> remote_desc_;
   // Candidates that arrived before the remote description was set.
   std::vector<IceCandidateInterface*> saved_candidates_;
   // If the remote peer is using a older version of implementation.
   bool older_version_remote_peer_;
   bool dtls_enabled_;
   // Specifies which kind of data channel is allowed. This is controlled
   // by the chrome command-line flag and constraints:
   // 1. If chrome command-line switch 'enable-sctp-data-channels' is enabled,
@@ skipping 20 matching lines @@
   PeerConnectionInterface::BundlePolicy bundle_policy_;
 
   // Declares the RTCP mux policy for the WebRTCSession.
   PeerConnectionInterface::RtcpMuxPolicy rtcp_mux_policy_;
 
   DISALLOW_COPY_AND_ASSIGN(WebRtcSession);
 };
 }  // namespace webrtc
 
 #endif  // TALK_APP_WEBRTC_WEBRTCSESSION_H_