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

talk/app/webrtc/mediastreamhandler.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 72 matching lines @@
 }
 
 LocalAudioTrackHandler::LocalAudioTrackHandler(
     AudioTrackInterface* track,
     uint32 ssrc,
     AudioProviderInterface* provider)
     : TrackHandler(track, ssrc),
       audio_track_(track),
       provider_(provider),
       sink_adapter_(new LocalAudioSinkAdapter()) {
-  OnEnabledChanged();
+  Start();
   track->AddSink(sink_adapter_.get());
 }
 
 LocalAudioTrackHandler::~LocalAudioTrackHandler() {
 }
 
 void LocalAudioTrackHandler::OnStateChanged() {
   // TODO(perkj): What should happen when the state change?
 }
 
+void LocalAudioTrackHandler::Start() {
+  OnEnabledChanged();
+}
+
 void LocalAudioTrackHandler::Stop() {
   audio_track_->RemoveSink(sink_adapter_.get());
   cricket::AudioOptions options;
   provider_->SetAudioSend(ssrc(), false, options, NULL);
 }
 
 void LocalAudioTrackHandler::OnEnabledChanged() {
   cricket::AudioOptions options;
   if (audio_track_->enabled() && audio_track_->GetSource()) {
     // TODO(xians): Remove this static_cast since we should be able to connect
@@ skipping 11 matching lines @@
 }
 
 RemoteAudioTrackHandler::RemoteAudioTrackHandler(
     AudioTrackInterface* track,
     uint32 ssrc,
     AudioProviderInterface* provider)
     : TrackHandler(track, ssrc),
       audio_track_(track),
       provider_(provider) {
   track->GetSource()->RegisterAudioObserver(this);
-  OnEnabledChanged();
+  Start();
 }
 
 RemoteAudioTrackHandler::~RemoteAudioTrackHandler() {
   audio_track_->GetSource()->UnregisterAudioObserver(this);
 }
 
+void RemoteAudioTrackHandler::Start() {
+  // TODO(deadbeef) - Should we remember the audio playout volume last set,
+  // and set it again in case the audio channel was destroyed and recreated?
+  OnEnabledChanged();
+}
+
 void RemoteAudioTrackHandler::Stop() {
   provider_->SetAudioPlayout(ssrc(), false, NULL);
 }
 
 void RemoteAudioTrackHandler::OnStateChanged() {
 }
 
 void RemoteAudioTrackHandler::OnEnabledChanged() {
   provider_->SetAudioPlayout(ssrc(), audio_track_->enabled(),
                              audio_track_->GetRenderer());
 }
 
 void RemoteAudioTrackHandler::OnSetVolume(double volume) {
   // When the track is disabled, the volume of the source, which is the
   // corresponding WebRtc Voice Engine channel will be 0. So we do not allow
   // setting the volume to the source when the track is disabled.
   if (audio_track_->enabled())
     provider_->SetAudioPlayoutVolume(ssrc(), volume);
 }
 
 LocalVideoTrackHandler::LocalVideoTrackHandler(
     VideoTrackInterface* track,
     uint32 ssrc,
     VideoProviderInterface* provider)
     : TrackHandler(track, ssrc),
       local_video_track_(track),
       provider_(provider) {
-  VideoSourceInterface* source = local_video_track_->GetSource();
-  if (source)
-    provider_->SetCaptureDevice(ssrc, source->GetVideoCapturer());
-  OnEnabledChanged();
+  Start();
 }
 
 LocalVideoTrackHandler::~LocalVideoTrackHandler() {
 }
 
 void LocalVideoTrackHandler::OnStateChanged() {
 }
 
+void LocalVideoTrackHandler::Start() {
+  VideoSourceInterface* source = local_video_track_->GetSource();
+  if (source)
+    provider_->SetCaptureDevice(ssrc(), source->GetVideoCapturer());
+  OnEnabledChanged();
+}
+
 void LocalVideoTrackHandler::Stop() {
   provider_->SetCaptureDevice(ssrc(), NULL);
   provider_->SetVideoSend(ssrc(), false, NULL);
 }
 
 void LocalVideoTrackHandler::OnEnabledChanged() {
   const cricket::VideoOptions* options = NULL;
   VideoSourceInterface* source = local_video_track_->GetSource();
   if (local_video_track_->enabled() && source) {
     options = source->options();
   }
   provider_->SetVideoSend(ssrc(), local_video_track_->enabled(), options);
 }
 
 RemoteVideoTrackHandler::RemoteVideoTrackHandler(
     VideoTrackInterface* track,
     uint32 ssrc,
     VideoProviderInterface* provider)
     : TrackHandler(track, ssrc),
       remote_video_track_(track),
       provider_(provider) {
-  OnEnabledChanged();
-  provider_->SetVideoPlayout(ssrc, true,
-                             remote_video_track_->GetSource()->FrameInput());
+  Start();
 }
 
 RemoteVideoTrackHandler::~RemoteVideoTrackHandler() {
 }
 
+void RemoteVideoTrackHandler::Start() {
+  OnEnabledChanged();
+  provider_->SetVideoPlayout(ssrc(), true,
+                             remote_video_track_->GetSource()->FrameInput());
+}
+
 void RemoteVideoTrackHandler::Stop() {
   // Since cricket::VideoRenderer is not reference counted
   // we need to remove the renderer before we are deleted.
   provider_->SetVideoPlayout(ssrc(), false, NULL);
 }
 
 void RemoteVideoTrackHandler::OnStateChanged() {
 }
 
 void RemoteVideoTrackHandler::OnEnabledChanged() {
@@ skipping 74 matching lines @@
 
 void LocalMediaStreamHandler::AddVideoTrack(VideoTrackInterface* video_track,
                                             uint32 ssrc) {
   ASSERT(!FindTrackHandler(video_track));
 
   TrackHandler* handler(new LocalVideoTrackHandler(video_track, ssrc,
                                                    video_provider_));
   track_handlers_.push_back(handler);
 }
 
+void LocalMediaStreamHandler::RestartAllTracks() {
+  for (auto it : track_handlers_) {
+    it->Start();
+  }
+}
+
 RemoteMediaStreamHandler::RemoteMediaStreamHandler(
     MediaStreamInterface* stream,
     AudioProviderInterface* audio_provider,
     VideoProviderInterface* video_provider)
     : MediaStreamHandler(stream, audio_provider, video_provider) {
 }
 
 RemoteMediaStreamHandler::~RemoteMediaStreamHandler() {
 }
 
 void RemoteMediaStreamHandler::AddAudioTrack(AudioTrackInterface* audio_track,
                                              uint32 ssrc) {
   ASSERT(!FindTrackHandler(audio_track));
   TrackHandler* handler(
       new RemoteAudioTrackHandler(audio_track, ssrc, audio_provider_));
   track_handlers_.push_back(handler);
 }
 
 void RemoteMediaStreamHandler::AddVideoTrack(VideoTrackInterface* video_track,
                                              uint32 ssrc) {
   ASSERT(!FindTrackHandler(video_track));
   TrackHandler* handler(
       new RemoteVideoTrackHandler(video_track, ssrc, video_provider_));
   track_handlers_.push_back(handler);
 }
 
+void RemoteMediaStreamHandler::RestartAllTracks() {
+  for (auto it : track_handlers_) {
+    it->Start();
+  }
+}
+
 MediaStreamHandlerContainer::MediaStreamHandlerContainer(
     AudioProviderInterface* audio_provider,
     VideoProviderInterface* video_provider)
     : audio_provider_(audio_provider),
       video_provider_(video_provider) {
 }
 
 MediaStreamHandlerContainer::~MediaStreamHandlerContainer() {
   ASSERT(remote_streams_handlers_.empty());
   ASSERT(local_streams_handlers_.empty());
@@ skipping 49 matching lines @@
   MediaStreamHandler* handler = FindStreamHandler(remote_streams_handlers_,
                                                   stream);
   if (!VERIFY(handler != NULL)) {
     LOG(LS_WARNING) << "Local MediaStreamHandler for stream  with id "
                     << stream->label() << "doesnt't exist.";
     return;
   }
   handler->RemoveTrack(track);
 }
 
+void MediaStreamHandlerContainer::RestartAllRemoteTracks() {
+  for (auto it : remote_streams_handlers_) {
+    it->RestartAllTracks();
+  }
+}
+
 void MediaStreamHandlerContainer::RemoveLocalStream(
     MediaStreamInterface* stream) {
   DeleteStreamHandler(&local_streams_handlers_, stream);
 }
 
 void MediaStreamHandlerContainer::AddLocalAudioTrack(
     MediaStreamInterface* stream,
     AudioTrackInterface* audio_track,
     uint32 ssrc) {
   MediaStreamHandler* handler = FindStreamHandler(local_streams_handlers_,
@@ skipping 22 matching lines @@
   MediaStreamHandler* handler = FindStreamHandler(local_streams_handlers_,
                                                   stream);
   if (!VERIFY(handler != NULL)) {
     LOG(LS_WARNING) << "Remote MediaStreamHandler for stream with id "
                     << stream->label() << "doesnt't exist.";
     return;
   }
   handler->RemoveTrack(track);
 }
 
+void MediaStreamHandlerContainer::RestartAllLocalTracks() {
+  for (auto it : local_streams_handlers_) {
+    it->RestartAllTracks();
+  }
+}
+
 MediaStreamHandler* MediaStreamHandlerContainer::CreateRemoteStreamHandler(
     MediaStreamInterface* stream) {
   ASSERT(!FindStreamHandler(remote_streams_handlers_, stream));
 
   RemoteMediaStreamHandler* handler =
       new RemoteMediaStreamHandler(stream, audio_provider_, video_provider_);
   remote_streams_handlers_.push_back(handler);
   return handler;
 }
 
@@ skipping 26 matching lines @@
     if ((*it)->stream() == stream) {
       (*it)->Stop();
       delete *it;
       streamhandlers->erase(it);
       break;
     }
   }
 }
 
 }  // namespace webrtc