Delete SignalSrtpError.

webrtc/pc/srtpfilter.h

 /*
  *  Copyright 2009 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.
  */
 
 #ifndef WEBRTC_PC_SRTPFILTER_H_
 #define WEBRTC_PC_SRTPFILTER_H_
 
 #include <list>
 #include <map>
 #include <memory>
 #include <string>
 #include <vector>
 
 #include "webrtc/base/basictypes.h"
 #include "webrtc/base/constructormagic.h"
 #include "webrtc/base/criticalsection.h"
-#include "webrtc/base/sigslotrepeater.h"
 #include "webrtc/base/sslstreamadapter.h"
 #include "webrtc/base/thread_checker.h"
 #include "webrtc/media/base/cryptoparams.h"
 #include "webrtc/p2p/base/sessiondescription.h"
 
 // Forward declaration to avoid pulling in libsrtp headers here
 struct srtp_event_data_t;
 struct srtp_ctx_t_;
 
 namespace cricket {
 
 class SrtpSession;
-class SrtpStat;
 
 void ShutdownSrtp();
 
 // Class to transform SRTP to/from RTP.
 // Initialize by calling SetSend with the local security params, then call
 // SetRecv once the remote security params are received. At that point
 // Protect/UnprotectRt(c)p can be called to encrypt/decrypt data.
 // TODO: Figure out concurrency policy for SrtpFilter.
 class SrtpFilter {
  public:
@@ skipping 73 matching lines @@
   // if it is actually used. This method is only valid before the RTP params
   // have been set.
   void EnableExternalAuth();
   bool IsExternalAuthEnabled() const;
 
   // A SRTP filter supports external creation of the auth tag if a non-GCM
   // cipher is used. This method is only valid after the RTP params have
   // been set.
   bool IsExternalAuthActive() const;
 
-  // Update the silent threshold (in ms) for signaling errors.
-  void set_signal_silent_time(int signal_silent_time_in_ms);
-
   bool ResetParams();
 
-  sigslot::repeater3<uint32_t, Mode, Error> SignalSrtpError;
-
  protected:
   bool ExpectOffer(ContentSource source);
   bool StoreParams(const std::vector<CryptoParams>& params,
                    ContentSource source);
   bool ExpectAnswer(ContentSource source);
   bool DoSetAnswer(const std::vector<CryptoParams>& answer_params,
                      ContentSource source,
                      bool final);
   void CreateSrtpSessions();
   bool NegotiateParams(const std::vector<CryptoParams>& answer_params,
@@ skipping 22 matching lines @@
     // SRTP filter is active but the sent answer is only provisional.
     // When the final answer is set, the state transitions to ST_ACTIVE or
     // ST_INIT.
     ST_SENTPRANSWER,
     // SRTP filter is active but the received answer is only provisional.
     // When the final answer is set, the state transitions to ST_ACTIVE or
     // ST_INIT.
     ST_RECEIVEDPRANSWER
   };
   State state_ = ST_INIT;
-  int signal_silent_time_in_ms_ = 0;
   bool external_auth_enabled_ = false;
   std::vector<CryptoParams> offer_params_;
   std::unique_ptr<SrtpSession> send_session_;
   std::unique_ptr<SrtpSession> recv_session_;
   std::unique_ptr<SrtpSession> send_rtcp_session_;
   std::unique_ptr<SrtpSession> recv_rtcp_session_;
   CryptoParams applied_send_params_;
   CryptoParams applied_recv_params_;
 };
 
@@ skipping 36 matching lines @@
   // if it is actually used. This method is only valid before the RTP params
   // have been set.
   void EnableExternalAuth();
   bool IsExternalAuthEnabled() const;
 
   // A SRTP session supports external creation of the auth tag if a non-GCM
   // cipher is used. This method is only valid after the RTP params have
   // been set.
   bool IsExternalAuthActive() const;
 
-  // Update the silent threshold (in ms) for signaling errors.
-  void set_signal_silent_time(int signal_silent_time_in_ms);
-
   // Calls srtp_shutdown if it's initialized.
   static void Terminate();
 
-  sigslot::repeater3<uint32_t, SrtpFilter::Mode, SrtpFilter::Error>
-      SignalSrtpError;
-
  private:
   bool SetKey(int type, int cs, const uint8_t* key, size_t len);
     // Returns send stream current packet index from srtp db.
   bool GetSendStreamPacketIndex(void* data, int in_len, int64_t* index);
 
   static bool Init();
   void HandleEvent(const srtp_event_data_t* ev);
   static void HandleEventThunk(srtp_event_data_t* ev);
 
   rtc::ThreadChecker thread_checker_;
   srtp_ctx_t_* session_ = nullptr;
   int rtp_auth_tag_len_ = 0;
   int rtcp_auth_tag_len_ = 0;
-  std::unique_ptr<SrtpStat> srtp_stat_;
   static bool inited_;
   static rtc::GlobalLockPod lock_;
   int last_send_seq_num_ = -1;
   bool external_auth_active_ = false;
   bool external_auth_enabled_ = false;
   RTC_DISALLOW_COPY_AND_ASSIGN(SrtpSession);
 };
 
-// Class that collects failures of SRTP.
-class SrtpStat {
- public:
-  SrtpStat();
-
-  // Report RTP protection results to the handler.
-  void AddProtectRtpResult(uint32_t ssrc, int result);
-  // Report RTP unprotection results to the handler.
-  void AddUnprotectRtpResult(uint32_t ssrc, int result);
-  // Report RTCP protection results to the handler.
-  void AddProtectRtcpResult(int result);
-  // Report RTCP unprotection results to the handler.
-  void AddUnprotectRtcpResult(int result);
-
-  // Get silent time (in ms) for SRTP statistics handler.
-  int signal_silent_time() const { return signal_silent_time_; }
-  // Set silent time (in ms) for SRTP statistics handler.
-  void set_signal_silent_time(int signal_silent_time) {
-    signal_silent_time_ = signal_silent_time;
-  }
-
-  // Sigslot for reporting errors.
-  sigslot::signal3<uint32_t, SrtpFilter::Mode, SrtpFilter::Error>
-      SignalSrtpError;
-
- private:
-  // For each different ssrc and error, we collect statistics separately.
-  struct FailureKey {
-    FailureKey()
-        : ssrc(0),
-          mode(SrtpFilter::PROTECT),
-          error(SrtpFilter::ERROR_NONE) {
-    }
-    FailureKey(uint32_t in_ssrc,
-               SrtpFilter::Mode in_mode,
-               SrtpFilter::Error in_error)
-        : ssrc(in_ssrc), mode(in_mode), error(in_error) {}
-    bool operator <(const FailureKey& key) const {
-      return
-          (ssrc < key.ssrc) ||
-          (ssrc == key.ssrc && mode < key.mode) ||
-          (ssrc == key.ssrc && mode == key.mode && error < key.error);
-    }
-    uint32_t ssrc;
-    SrtpFilter::Mode mode;
-    SrtpFilter::Error error;
-  };
-  // For tracing conditions for signaling, currently we only use
-  // last_signal_time.  Wrap this as a struct so that later on, if we need any
-  // other improvements, it will be easier.
-  struct FailureStat {
-    FailureStat()
-        : last_signal_time(0) {
-    }
-    explicit FailureStat(uint32_t in_last_signal_time)
-        : last_signal_time(in_last_signal_time) {}
-    void Reset() {
-      last_signal_time = 0;
-    }
-    int64_t last_signal_time;
-  };
-
-  // Inspect SRTP result and signal error if needed.
-  void HandleSrtpResult(const FailureKey& key);
-
-  std::map<FailureKey, FailureStat> failures_;
-  // Threshold in ms to silent the signaling errors.
-  int signal_silent_time_;
-
-  RTC_DISALLOW_COPY_AND_ASSIGN(SrtpStat);
-};
-
 }  // namespace cricket
 
 #endif  // WEBRTC_PC_SRTPFILTER_H_