Fixing scenario where track is rejected and later un-rejected.

talk/app/webrtc/mediastreamsignaling.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 507 matching lines @@
   }
   MaybeCreateDefaultStream();
 }
 
 void MediaStreamSignaling::OnLocalDescriptionChanged(
     const SessionDescriptionInterface* desc) {
   const cricket::ContentInfo* audio_content =
       GetFirstAudioContent(desc->description());
   if (audio_content) {
     if (audio_content->rejected) {
-      RejectRemoteTracks(cricket::MEDIA_TYPE_AUDIO);
+      SetRemoteTracksState(cricket::MEDIA_TYPE_AUDIO,
+                           MediaStreamTrackInterface::kEnded);
+    } else {
+      // This is needed in case the local description caused the track to be
+      // rejected, then later accepted, without being destroyed.
+      SetRemoteTracksState(cricket::MEDIA_TYPE_AUDIO,
+                           MediaStreamTrackInterface::kLive);
     }
     const cricket::AudioContentDescription* audio_desc =
         static_cast<const cricket::AudioContentDescription*>(
             audio_content->description);
     UpdateLocalTracks(audio_desc->streams(), audio_desc->type());
   }
 
   const cricket::ContentInfo* video_content =
       GetFirstVideoContent(desc->description());
   if (video_content) {
     if (video_content->rejected) {
-      RejectRemoteTracks(cricket::MEDIA_TYPE_VIDEO);
+      SetRemoteTracksState(cricket::MEDIA_TYPE_VIDEO,
+                           MediaStreamTrackInterface::kEnded);
+    } else {
+      // This is needed in case the local description caused the track to be
+      // rejected, then later accepted, without being destroyed.
+      SetRemoteTracksState(cricket::MEDIA_TYPE_VIDEO,
+                           MediaStreamTrackInterface::kLive);
     }
     const cricket::VideoContentDescription* video_desc =
         static_cast<const cricket::VideoContentDescription*>(
             video_content->description);
     UpdateLocalTracks(video_desc->streams(), video_desc->type());
   }
 
   const cricket::ContentInfo* data_content =
       GetFirstDataContent(desc->description());
   if (data_content) {
     const cricket::DataContentDescription* data_desc =
         static_cast<const cricket::DataContentDescription*>(
             data_content->description);
     if (rtc::starts_with(
             data_desc->protocol().data(), cricket::kMediaProtocolRtpPrefix)) {
       UpdateLocalRtpDataChannels(data_desc->streams());
     }
   }
 }
 
 void MediaStreamSignaling::OnAudioChannelClose() {
-  RejectRemoteTracks(cricket::MEDIA_TYPE_AUDIO);
+  SetRemoteTracksState(cricket::MEDIA_TYPE_AUDIO,
+                       MediaStreamTrackInterface::kEnded);
 }
 
 void MediaStreamSignaling::OnVideoChannelClose() {
-  RejectRemoteTracks(cricket::MEDIA_TYPE_VIDEO);
+  SetRemoteTracksState(cricket::MEDIA_TYPE_VIDEO,
+                       MediaStreamTrackInterface::kEnded);
 }
 
 void MediaStreamSignaling::OnDataChannelClose() {
   // Use a temporary copy of the RTP/SCTP DataChannel list because the
   // DataChannel may callback to us and try to modify the list.
   RtpDataChannels temp_rtp_dcs;
   temp_rtp_dcs.swap(rtp_data_channels_);
   RtpDataChannels::iterator it1 = temp_rtp_dcs.begin();
   for (; it1 != temp_rtp_dcs.end(); ++it1) {
     it1->second->OnDataEngineClose();
@@ skipping 94 matching lines @@
     if (video_track) {
       video_track->set_state(webrtc::MediaStreamTrackInterface::kEnded);
       stream->RemoveTrack(video_track);
       stream_observer_->OnRemoveRemoteVideoTrack(stream, video_track);
     }
   } else {
     ASSERT(false && "Invalid media type");
   }
 }
 
-void MediaStreamSignaling::RejectRemoteTracks(cricket::MediaType media_type) {
+void MediaStreamSignaling::SetRemoteTracksState(
+    cricket::MediaType media_type,
+    MediaStreamTrackInterface::TrackState state) {
   TrackInfos* current_tracks = GetRemoteTracks(media_type);
   for (TrackInfos::iterator track_it = current_tracks->begin();
        track_it != current_tracks->end(); ++track_it) {
     const TrackInfo& info = *track_it;
     MediaStreamInterface* stream = remote_streams_->find(info.stream_label);
     if (media_type == cricket::MEDIA_TYPE_AUDIO) {
       AudioTrackInterface* track = stream->FindAudioTrack(info.track_id);
       // There's no guarantee the track is still available, e.g. the track may
       // have been removed from the stream by javascript.
       if (track) {
-        track->set_state(webrtc::MediaStreamTrackInterface::kEnded);
+        track->set_state(state);
       }
     }
     if (media_type == cricket::MEDIA_TYPE_VIDEO) {
       VideoTrackInterface* track = stream->FindVideoTrack(info.track_id);
       // There's no guarantee the track is still available, e.g. the track may
       // have been removed from the stream by javascript.
       if (track) {
-        track->set_state(webrtc::MediaStreamTrackInterface::kEnded);
+        track->set_state(state);
       }
     }
   }
 }
 
 void MediaStreamSignaling::UpdateEndedRemoteMediaStreams() {
   std::vector<scoped_refptr<MediaStreamInterface> > streams_to_remove;
   for (size_t i = 0; i < remote_streams_->count(); ++i) {
     MediaStreamInterface*stream = remote_streams_->at(i);
     if (stream->GetAudioTracks().empty() && stream->GetVideoTracks().empty()) {
@@ skipping 310 matching lines @@
 int MediaStreamSignaling::FindDataChannelBySid(int sid) const {
   for (size_t i = 0; i < sctp_data_channels_.size(); ++i) {
     if (sctp_data_channels_[i]->id() == sid) {
       return static_cast<int>(i);
     }
   }
   return -1;
 }
 
 }  // namespace webrtc