Change VideoRtpReceiver to create remote VideoTrack and VideoTrackSource.

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 363 matching lines @@
   }
 }
 
 }  // namespace
 
 namespace webrtc {
 
 // Factory class for creating remote MediaStreams and MediaStreamTracks.
 class RemoteMediaStreamFactory {
  public:
-  explicit RemoteMediaStreamFactory(rtc::Thread* signaling_thread,
-                                    rtc::Thread* worker_thread)
-      : signaling_thread_(signaling_thread),
-        worker_thread_(worker_thread) {}
+  explicit RemoteMediaStreamFactory(rtc::Thread* signaling_thread)
+      : signaling_thread_(signaling_thread) {}
 
   rtc::scoped_refptr<MediaStreamInterface> CreateMediaStream(
       const std::string& stream_label) {
     return MediaStreamProxy::Create(signaling_thread_,
                                     MediaStream::Create(stream_label));
   }
 
   AudioTrackInterface* AddAudioTrack(uint32_t ssrc,
                                      AudioProviderInterface* provider,
                                      webrtc::MediaStreamInterface* stream,
                                      const std::string& track_id) {
     return AddTrack<AudioTrackInterface, AudioTrack, AudioTrackProxy>(
         stream, track_id, RemoteAudioSource::Create(ssrc, provider));
   }
 
-  VideoTrackInterface* AddVideoTrack(webrtc::MediaStreamInterface* stream,
-                                     const std::string& track_id) {
-    return AddTrack<VideoTrackInterface, VideoTrack, VideoTrackProxy>(
-        stream, track_id,
-        VideoCapturerTrackSource::Create(
-            worker_thread_, new RemoteVideoCapturer(), nullptr, true)
-            .get());
-  }
-
  private:
   template <typename TI, typename T, typename TP, typename S>
   TI* AddTrack(MediaStreamInterface* stream,
                const std::string& track_id,
                const S& source) {
     rtc::scoped_refptr<TI> track(
         TP::Create(signaling_thread_, T::Create(track_id, source)));
     track->set_state(webrtc::MediaStreamTrackInterface::kLive);
     if (stream->AddTrack(track)) {
       return track;
     }
     return nullptr;
   }
 
   rtc::Thread* signaling_thread_;
-  rtc::Thread* worker_thread_;
 };
 
 bool ExtractMediaSessionOptions(
     const PeerConnectionInterface::RTCOfferAnswerOptions& rtc_options,
     cricket::MediaSessionOptions* session_options) {
   typedef PeerConnectionInterface::RTCOfferAnswerOptions RTCOfferAnswerOptions;
   if (!IsValidOfferToReceiveMedia(rtc_options.offer_to_receive_audio) ||
       !IsValidOfferToReceiveMedia(rtc_options.offer_to_receive_video)) {
     return false;
   }
@@ skipping 166 matching lines @@
     portallocator_flags |= cricket::PORTALLOCATOR_DISABLE_TCP;
     LOG(LS_INFO) << "TCP candidates are disabled.";
   }
 
   port_allocator_->set_flags(portallocator_flags);
   // No step delay is used while allocating ports.
   port_allocator_->set_step_delay(cricket::kMinimumStepDelay);
 
   media_controller_.reset(factory_->CreateMediaController(media_config));
 
-  remote_stream_factory_.reset(new RemoteMediaStreamFactory(
-      factory_->signaling_thread(), factory_->worker_thread()));
+  remote_stream_factory_.reset(
+      new RemoteMediaStreamFactory(factory_->signaling_thread()));
 
   session_.reset(
       new WebRtcSession(media_controller_.get(), factory_->signaling_thread(),
                         factory_->worker_thread(), port_allocator_.get()));
   stats_.reset(new StatsCollector(this));
 
   // Initialize the WebRtcSession. It creates transport channels etc.
   if (!session_->Initialize(factory_->options(), std::move(dtls_identity_store),
                             configuration)) {
     return false;
@@ skipping 691 matching lines @@
 }
 
 void PeerConnection::CreateAudioReceiver(MediaStreamInterface* stream,
                                          AudioTrackInterface* audio_track,
                                          uint32_t ssrc) {
   receivers_.push_back(RtpReceiverProxy::Create(
       signaling_thread(),
       new AudioRtpReceiver(audio_track, ssrc, session_.get())));
 }
 
-void PeerConnection::CreateVideoReceiver(MediaStreamInterface* stream,
-                                         VideoTrackInterface* video_track,
-                                         uint32_t ssrc) {
-  receivers_.push_back(RtpReceiverProxy::Create(
-      signaling_thread(),
-      new VideoRtpReceiver(video_track, ssrc, session_.get())));
+VideoRtpReceiver* PeerConnection::CreateVideoReceiver(
+    const std::string& track_id,
+    uint32_t ssrc) {
+  VideoRtpReceiver* video_receiver = new VideoRtpReceiver(
+      track_id, factory_->worker_thread(), ssrc, session_.get());
+  // RtpReceiverProxy takes ownership of |video_receiver|;
+  receivers_.push_back(
+      RtpReceiverProxy::Create(signaling_thread(), video_receiver));
+  return video_receiver;

[pthatcher1, 2016/03/09 18:16:49]

Why do we keep ownership of the proxy but then return the non-proxy?  That seems
weird.

[perkj_webrtc, 2016/03/09 21:22:59]

That is my attempt to avoid a static cast and to be able to get a
videotrackinterface and not a mediastreamtrack from the VideoRtpReceiver. I can
have this method return a VideoRtpReceiverInteface and return the proxy if I add
a new method to the interface. Let me try that and see if  you like it better.

[Taylor Brandstetter, 2016/03/09 22:10:41]

I assume you mean "return an RtpReceiverInterface"? I'm actually planning on
cleaning up that interface so it doesn't have any methods besides those in the
spec. So I'd prefer the current implementation. Or better yet, pass a stream
into CreateVideoReceiver and add the track to the stream within the method, to
avoid the need for returning anything.

[perkj_webrtc, 2016/03/10 00:26:38]

that is a very good idea.

 }
 
 // TODO(deadbeef): Keep RtpReceivers around even if track goes away in remote
 // description.
 void PeerConnection::DestroyAudioReceiver(MediaStreamInterface* stream,
                                           AudioTrackInterface* audio_track) {
   auto it = FindReceiverForTrack(audio_track);
   if (it == receivers_.end()) {
     LOG(LS_WARNING) << "RtpReceiver for track with id " << audio_track->id()
                     << " doesn't exist.";
@@ skipping 327 matching lines @@
                                        const std::string& track_id,
                                        uint32_t ssrc,
                                        cricket::MediaType media_type) {
   MediaStreamInterface* stream = remote_streams_->find(stream_label);
 
   if (media_type == cricket::MEDIA_TYPE_AUDIO) {
     AudioTrackInterface* audio_track = remote_stream_factory_->AddAudioTrack(
         ssrc, session_.get(), stream, track_id);
     CreateAudioReceiver(stream, audio_track, ssrc);
   } else if (media_type == cricket::MEDIA_TYPE_VIDEO) {
-    VideoTrackInterface* video_track =
-        remote_stream_factory_->AddVideoTrack(stream, track_id);
-    CreateVideoReceiver(stream, video_track, ssrc);
+    VideoRtpReceiver* receiver = CreateVideoReceiver(track_id, ssrc);
+    stream->AddTrack(receiver->video_track());
   } else {
     RTC_DCHECK(false && "Invalid media type");
   }
 }
 
 void PeerConnection::OnRemoteTrackRemoved(const std::string& stream_label,
                                           const std::string& track_id,
                                           cricket::MediaType media_type) {
   MediaStreamInterface* stream = remote_streams_->find(stream_label);
 
   if (media_type == cricket::MEDIA_TYPE_AUDIO) {
     rtc::scoped_refptr<AudioTrackInterface> audio_track =
         stream->FindAudioTrack(track_id);
     if (audio_track) {
       audio_track->set_state(webrtc::MediaStreamTrackInterface::kEnded);
       stream->RemoveTrack(audio_track);
       DestroyAudioReceiver(stream, audio_track);
     }
   } else if (media_type == cricket::MEDIA_TYPE_VIDEO) {
     rtc::scoped_refptr<VideoTrackInterface> video_track =
         stream->FindVideoTrack(track_id);
     if (video_track) {
-      video_track->set_state(webrtc::MediaStreamTrackInterface::kEnded);
       stream->RemoveTrack(video_track);
       DestroyVideoReceiver(stream, video_track);

[pthatcher1, 2016/03/09 18:16:49]

Can you put a comment here saying "Stopping or destroying a VideoRtpReceiver
will end VideoRtpReceiver::track()"?

[perkj_webrtc, 2016/03/09 21:22:59]

Done.

     }
   } else {
     ASSERT(false && "Invalid media type");
   }
 }
 
 void PeerConnection::UpdateEndedRemoteMediaStreams() {
   std::vector<rtc::scoped_refptr<MediaStreamInterface>> streams_to_remove;
   for (size_t i = 0; i < remote_streams_->count(); ++i) {
     MediaStreamInterface* stream = remote_streams_->at(i);
@@ skipping 394 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