Cast: deliver video frames on the IO thread

content/renderer/media/media_stream_video_track.cc

 // Copyright 2013 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "content/renderer/media/media_stream_video_track.h"
 
 #include "base/bind.h"
 #include "content/renderer/media/video_frame_deliverer.h"
 #include "media/base/bind_to_current_loop.h"
 
 namespace content {
 
 // Helper class used for delivering video frames to MediaStreamSinks on the
-// IO-thread and MediaStreamVideoSinks on the main render thread.
+// IO-thread.
 // Frames are delivered to an instance of this class from a
 // MediaStreamVideoSource on the IO-thread to the method DeliverFrameOnIO.
 // Frames are only delivered to the sinks if the track is enabled.
 class MediaStreamVideoTrack::FrameDeliverer : public VideoFrameDeliverer {
  public:
   FrameDeliverer(
       const scoped_refptr<base::MessageLoopProxy>& io_message_loop_proxy,
       bool enabled)
       : VideoFrameDeliverer(io_message_loop_proxy),
         enabled_(enabled) {
   }
 
-  // Add |sink| to receive frames and state changes on the main render thread.
-  void AddSink(MediaStreamVideoSink* sink) {
+  // Add |sink| to receive state changes on the main render thread.
+  // Video frames will be delivered to |callback| on the IO thread.
+  void AddSink(MediaStreamVideoSink* sink,
+               const VideoCaptureDeliverFrameCB& callback) {
     DCHECK(thread_checker().CalledOnValidThread());
     DCHECK(std::find(sinks_.begin(), sinks_.end(), sink) == sinks_.end());
-    if (sinks_.empty()) {
-      VideoCaptureDeliverFrameCB frame_callback = media::BindToCurrentLoop(
-          base::Bind(
-              &MediaStreamVideoTrack::FrameDeliverer::OnVideoFrameOnMainThread,
-              this));
-      AddCallback(this, frame_callback);
-    }
-
     sinks_.push_back(sink);
+    AddCallback(sink, callback);
   }
 
   void RemoveSink(MediaStreamVideoSink* sink) {
     DCHECK(thread_checker().CalledOnValidThread());
     std::vector<MediaStreamVideoSink*>::iterator it =
         std::find(sinks_.begin(), sinks_.end(), sink);
     DCHECK(it != sinks_.end());
     sinks_.erase(it);
-    if (sinks_.empty()) {
-      RemoveCallback(this);
-    }
-  }
-
-  // Called when a video frame is received on the main render thread.
-  // It delivers the received frames to the registered MediaStreamVideo sinks.
-  void OnVideoFrameOnMainThread(
-      const scoped_refptr<media::VideoFrame>& frame,
-      const media::VideoCaptureFormat& format) {
-    DCHECK(thread_checker().CalledOnValidThread());
-    for (std::vector<MediaStreamVideoSink*>::iterator it = sinks_.begin();
-         it != sinks_.end(); ++it) {
-      (*it)->OnVideoFrame(frame);
-    }
+    RemoveCallback(sink);
   }
 
   void SetEnabled(bool enabled) {
     DCHECK(thread_checker().CalledOnValidThread());
     io_message_loop()->PostTask(
         FROM_HERE,
         base::Bind(&MediaStreamVideoTrack::FrameDeliverer::SetEnabledOnIO,
                    this, enabled));
   }
 
@@ skipping 65 matching lines @@
                        &MediaStreamVideoTrack::FrameDeliverer::DeliverFrameOnIO,
                        frame_deliverer_),
                    constraints, callback);
 }
 
 MediaStreamVideoTrack::~MediaStreamVideoTrack() {
   Stop();
   DVLOG(3) << "~MediaStreamVideoTrack()";
 }
 
-void MediaStreamVideoTrack::AddSink(MediaStreamVideoSink* sink) {
+void MediaStreamVideoTrack::AddSink(
+    MediaStreamVideoSink* sink, const VideoCaptureDeliverFrameCB& callback) {
   DCHECK(thread_checker_.CalledOnValidThread());
-  frame_deliverer_->AddSink(sink);
+  frame_deliverer_->AddSink(sink, callback);
 }
 
 void MediaStreamVideoTrack::RemoveSink(MediaStreamVideoSink* sink) {
   DCHECK(thread_checker_.CalledOnValidThread());
   frame_deliverer_->RemoveSink(sink);
 }
 
-void MediaStreamVideoTrack::AddSink(
-    MediaStreamSink* sink, const VideoCaptureDeliverFrameCB& callback) {
-  DCHECK(thread_checker_.CalledOnValidThread());
-  frame_deliverer_->AddCallback(sink, callback);
-}
-
-void MediaStreamVideoTrack::RemoveSink(MediaStreamSink* sink) {
-  DCHECK(thread_checker_.CalledOnValidThread());
-  frame_deliverer_->RemoveCallback(sink);
-}
-
 void MediaStreamVideoTrack::SetEnabled(bool enabled) {
   DCHECK(thread_checker_.CalledOnValidThread());
   MediaStreamTrack::SetEnabled(enabled);
 
   frame_deliverer_->SetEnabled(enabled);
   const std::vector<MediaStreamVideoSink*>& sinks = frame_deliverer_->sinks();
   for (std::vector<MediaStreamVideoSink*>::const_iterator it = sinks.begin();
        it != sinks.end(); ++it) {
     (*it)->OnEnabledChanged(enabled);
   }
@@ skipping 12 matching lines @@
     blink::WebMediaStreamSource::ReadyState state) {
   DCHECK(thread_checker_.CalledOnValidThread());
   const std::vector<MediaStreamVideoSink*>& sinks = frame_deliverer_->sinks();
   for (std::vector<MediaStreamVideoSink*>::const_iterator it = sinks.begin();
        it != sinks.end(); ++it) {
     (*it)->OnReadyStateChanged(state);
   }
 }
 
 }  // namespace content