Remove global list of SRTP sessions.

talk/session/media/srtpfilter.cc

 /*
  * libjingle
  * Copyright 2009 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 463 matching lines @@
   return true;
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 // SrtpSession
 
 #ifdef HAVE_SRTP
 
 bool SrtpSession::inited_ = false;
 
-// This lock protects SrtpSession::inited_ and SrtpSession::sessions_.
+// This lock protects SrtpSession::inited_.
 rtc::GlobalLockPod SrtpSession::lock_;
 
 SrtpSession::SrtpSession()
     : session_(NULL),
       rtp_auth_tag_len_(0),
       rtcp_auth_tag_len_(0),
       srtp_stat_(new SrtpStat()),
       last_send_seq_num_(-1) {
-  {
-    rtc::GlobalLockScope ls(&lock_);
-    sessions()->push_back(this);
-  }
   SignalSrtpError.repeat(srtp_stat_->SignalSrtpError);
 }
 
 SrtpSession::~SrtpSession() {
-  {
-    rtc::GlobalLockScope ls(&lock_);
-    sessions()->erase(std::find(sessions()->begin(), sessions()->end(), this));
-  }
   if (session_) {
+    session_->user_data = nullptr;
     srtp_dealloc(session_);
   }
 }
 
 bool SrtpSession::SetSend(const std::string& cs, const uint8_t* key, int len) {
   return SetKey(ssrc_any_outbound, cs, key, len);
 }
 
 bool SrtpSession::SetRecv(const std::string& cs, const uint8_t* key, int len) {
   return SetKey(ssrc_any_inbound, cs, key, len);
@@ skipping 194 matching lines @@
 #endif
   policy.next = NULL;
 
   int err = srtp_create(&session_, &policy);
   if (err != err_status_ok) {
     session_ = NULL;
     LOG(LS_ERROR) << "Failed to create SRTP session, err=" << err;
     return false;
   }
 
-
+  session_->user_data = this;
   rtp_auth_tag_len_ = policy.rtp.auth_tag_len;
   rtcp_auth_tag_len_ = policy.rtcp.auth_tag_len;
   return true;
 }
 
 bool SrtpSession::Init() {
   rtc::GlobalLockScope ls(&lock_);
 
   if (!inited_) {
     int err;
@@ skipping 48 matching lines @@
     case event_packet_index_limit:
       LOG(LS_INFO) << "SRTP event: reached hard packet limit (2^48 packets)";
       break;
     default:
       LOG(LS_INFO) << "SRTP event: unknown " << ev->event;
       break;
   }
 }
 
 void SrtpSession::HandleEventThunk(srtp_event_data_t* ev) {
-  rtc::GlobalLockScope ls(&lock_);
-
-  for (std::list<SrtpSession*>::iterator it = sessions()->begin();
-       it != sessions()->end(); ++it) {
-    if ((*it)->session_ == ev->session) {
-      (*it)->HandleEvent(ev);
-      break;
-    }
+  SrtpSession* session = static_cast<SrtpSession*>(ev->session->user_data);

[juberti, 2015/11/10 01:25:59]

Do we know what thread this gets invoked from? Would be good to document it to
ensure proper locking.

[joachim, 2015/11/10 16:59:56]

Done.

+  if (session) {
+    session->HandleEvent(ev);
   }
 }
 
-std::list<SrtpSession*>* SrtpSession::sessions() {
-  RTC_DEFINE_STATIC_LOCAL(std::list<SrtpSession*>, sessions, ());
-  return &sessions;
-}
-
 #else   // !HAVE_SRTP
 
 // On some systems, SRTP is not (yet) available.
 
 SrtpSession::SrtpSession() {
   LOG(WARNING) << "SRTP implementation is missing.";
 }
 
 SrtpSession::~SrtpSession() {
 }
@@ skipping 127 matching lines @@
   SrtpNotAvailable(__FUNCTION__);
 }
 
 void SrtpStat::HandleSrtpResult(const SrtpStat::FailureKey& key) {
   SrtpNotAvailable(__FUNCTION__);
 }
 
 #endif  // HAVE_SRTP
 
 }  // namespace cricket