Free SCTP data channels asynchronously in PeerConnection.

talk/app/webrtc/peerconnection.cc

 /*
  * 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 88 matching lines @@
 };
 static_assert(INVALID == arraysize(kValidIceServiceTypes),
               "kValidIceServiceTypes must have as many strings as ServiceType "
               "has values.");
 
 enum {
   MSG_SET_SESSIONDESCRIPTION_SUCCESS = 0,
   MSG_SET_SESSIONDESCRIPTION_FAILED,
   MSG_CREATE_SESSIONDESCRIPTION_FAILED,
   MSG_GETSTATS,
+  MSG_DELETE,
 };
 
 struct SetSessionDescriptionMsg : public rtc::MessageData {
   explicit SetSessionDescriptionMsg(
       webrtc::SetSessionDescriptionObserver* observer)
       : observer(observer) {
   }
 
   rtc::scoped_refptr<webrtc::SetSessionDescriptionObserver> observer;
   std::string error;
@@ skipping 469 matching lines @@
       uma_observer_(NULL),
       signaling_state_(kStable),
       ice_state_(kIceNew),
       ice_connection_state_(kIceConnectionNew),
       ice_gathering_state_(kIceGatheringNew),
       local_streams_(StreamCollection::Create()),
       remote_streams_(StreamCollection::Create()) {}
 
 PeerConnection::~PeerConnection() {
   RTC_DCHECK(signaling_thread()->IsCurrent());
+  // Finish any pending deletions.
+  signaling_thread()->Clear(this, MSG_DELETE, nullptr);
   // Need to detach RTP senders/receivers from WebRtcSession,
   // since it's about to be destroyed.
   for (const auto& sender : senders_) {
     sender->Stop();
   }
   for (const auto& receiver : receivers_) {
     receiver->Stop();
   }
 }
 
@@ skipping 698 matching lines @@
       break;
     }
     case MSG_GETSTATS: {
       GetStatsMsg* param = static_cast<GetStatsMsg*>(msg->pdata);
       StatsReports reports;
       stats_->GetStats(param->track, &reports);
       param->observer->OnComplete(reports);
       delete param;
       break;
     }
+    case MSG_DELETE: {
+      delete msg->pdata;
+      break;
+    }
     default:
       RTC_DCHECK(false && "Not implemented");
       break;
   }
 }
 
 void PeerConnection::CreateAudioReceiver(MediaStreamInterface* stream,
                                          AudioTrackInterface* audio_track,
                                          uint32_t ssrc) {
   receivers_.push_back(new AudioRtpReceiver(audio_track, ssrc, session_.get()));
@@ skipping 567 matching lines @@
   }
 }
 
 void PeerConnection::OnSctpDataChannelClosed(DataChannel* channel) {
   for (auto it = sctp_data_channels_.begin(); it != sctp_data_channels_.end();
        ++it) {
     if (it->get() == channel) {
       if (channel->id() >= 0) {
         sid_allocator_.ReleaseSid(channel->id());
       }
+      // Since this method is triggered by a signal from the DataChannel,
+      // we can't free it directly here; we need to free it asynchronously.
+      signaling_thread()->Post(
+          this, MSG_DELETE,
+          new rtc::TypedMessageData<rtc::scoped_refptr<DataChannel>>(channel));
       sctp_data_channels_.erase(it);
       return;
     }
   }
 }
 
 void PeerConnection::OnVoiceChannelDestroyed() {
   EndRemoteTracks(cricket::MEDIA_TYPE_AUDIO);
 }
 
@@ skipping 96 matching lines @@
 DataChannel* PeerConnection::FindDataChannelBySid(int sid) const {
   for (const auto& channel : sctp_data_channels_) {
     if (channel->id() == sid) {
       return channel;
     }
   }
   return nullptr;
 }
 
 }  // namespace webrtc