Add PeerConnection IsClosed check.

webrtc/api/peerconnection.cc

 /*
  *  Copyright 2012 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 740 matching lines @@
   (*it)->Stop();
   senders_.erase(it);
 
   observer_->OnRenegotiationNeeded();
   return true;
 }
 
 rtc::scoped_refptr<DtmfSenderInterface> PeerConnection::CreateDtmfSender(
     AudioTrackInterface* track) {
   TRACE_EVENT0("webrtc", "PeerConnection::CreateDtmfSender");
+  if (IsClosed()) {
+    return nullptr;
+  }
   if (!track) {
     LOG(LS_ERROR) << "CreateDtmfSender - track is NULL.";
     return NULL;
   }
   if (!local_streams_->FindAudioTrack(track->id())) {
     LOG(LS_ERROR) << "CreateDtmfSender is called with a non local audio track.";
     return NULL;
   }
 
   rtc::scoped_refptr<DtmfSenderInterface> sender(
       DtmfSender::Create(track, signaling_thread(), session_.get()));
   if (!sender.get()) {
     LOG(LS_ERROR) << "CreateDtmfSender failed on DtmfSender::Create.";
     return NULL;
   }
   return DtmfSenderProxy::Create(signaling_thread(), sender.get());
 }
 
 rtc::scoped_refptr<RtpSenderInterface> PeerConnection::CreateSender(
     const std::string& kind,
     const std::string& stream_id) {
   TRACE_EVENT0("webrtc", "PeerConnection::CreateSender");
+  if (IsClosed()) {
+    return nullptr;
+  }
   rtc::scoped_refptr<RtpSenderInterface> new_sender;
   if (kind == MediaStreamTrackInterface::kAudioKind) {
     new_sender = RtpSenderProxy::Create(
         signaling_thread(), new AudioRtpSender(session_.get(), stats_.get()));
   } else if (kind == MediaStreamTrackInterface::kVideoKind) {
     new_sender = RtpSenderProxy::Create(signaling_thread(),
                                         new VideoRtpSender(session_.get()));
   } else {
     LOG(LS_ERROR) << "CreateSender called with invalid kind: " << kind;
     return new_sender;
@@ skipping 375 matching lines @@
     }
     port_allocator_->SetIceServers(stun_servers, turn_servers);
   }
   session_->SetIceConfig(session_->ParseIceConfig(config));
   return session_->SetIceTransports(config.type);
 }
 
 bool PeerConnection::AddIceCandidate(
     const IceCandidateInterface* ice_candidate) {
   TRACE_EVENT0("webrtc", "PeerConnection::AddIceCandidate");
+  if (IsClosed()) {
+    return false;
+  }
   return session_->ProcessIceMessage(ice_candidate);
 }
 
 bool PeerConnection::RemoveIceCandidates(
     const std::vector<cricket::Candidate>& candidates) {
   TRACE_EVENT0("webrtc", "PeerConnection::RemoveIceCandidates");
   return session_->RemoveRemoteIceCandidates(candidates);
 }
 
 void PeerConnection::RegisterUMAObserver(UMAObserver* observer) {
@@ skipping 101 matching lines @@
     }
     default:
       RTC_DCHECK(false && "Not implemented");
       break;
   }
 }
 
 void PeerConnection::CreateAudioReceiver(MediaStreamInterface* stream,
                                          const std::string& track_id,
                                          uint32_t ssrc) {
+  if (IsClosed()) {
+    return;
+  }

[Taylor Brandstetter, 2016/05/11 22:18:36]

This and CreateVideoReceiver are internal methods, only called from
SetRemoteDescription. So I think the check should occur earlier, in
SetRemoteDescription (with another for SetLocalDescription).

[Zhi Huang, 2016/05/12 01:25:49]

Done.

   receivers_.push_back(RtpReceiverProxy::Create(
       signaling_thread(),
       new AudioRtpReceiver(stream, track_id, ssrc, session_.get())));
 }
 
 void PeerConnection::CreateVideoReceiver(MediaStreamInterface* stream,
                                          const std::string& track_id,
                                          uint32_t ssrc) {
+  if (IsClosed()) {
+    return;
+  }
   receivers_.push_back(RtpReceiverProxy::Create(
       signaling_thread(),
       new VideoRtpReceiver(stream, track_id, factory_->worker_thread(), ssrc,
                            session_.get())));
 }
 
 // TODO(deadbeef): Keep RtpReceivers around even if track goes away in remote
 // description.
 void PeerConnection::DestroyReceiver(const std::string& track_id) {
   auto it = FindReceiverForTrack(track_id);
@@ skipping 36 matching lines @@
   RTC_DCHECK(signaling_thread()->IsCurrent());
   if (IsClosed()) {
     return;
   }
   ice_gathering_state_ = new_state;
   observer_->OnIceGatheringChange(ice_gathering_state_);
 }
 
 void PeerConnection::OnIceCandidate(const IceCandidateInterface* candidate) {
   RTC_DCHECK(signaling_thread()->IsCurrent());
+  if (IsClosed()) {
+    return;
+  }
   observer_->OnIceCandidate(candidate);
 }
 
 void PeerConnection::OnIceCandidatesRemoved(
     const std::vector<cricket::Candidate>& candidates) {
   RTC_DCHECK(signaling_thread()->IsCurrent());
+  if (IsClosed()) {
+    return;
+  }
   observer_->OnIceCandidatesRemoved(candidates);
 }
 
 void PeerConnection::OnIceConnectionReceivingChange(bool receiving) {
   RTC_DCHECK(signaling_thread()->IsCurrent());
+  if (IsClosed()) {
+    return;
+  }
   observer_->OnIceConnectionReceivingChange(receiving);
 }
 
 void PeerConnection::ChangeSignalingState(
     PeerConnectionInterface::SignalingState signaling_state) {
   signaling_state_ = signaling_state;
   if (signaling_state == kClosed) {
     ice_connection_state_ = kIceConnectionClosed;
     observer_->OnIceConnectionChange(ice_connection_state_);
     if (ice_gathering_state_ != kIceGatheringComplete) {
@@ skipping 694 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