Change a disabled MediaStreamVideoTrack to output black video frames for each incoming frame.

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 <utility>
 
 #include "base/bind.h"
 
 namespace content {
 
 namespace {
 void ResetCallback(scoped_ptr<VideoCaptureDeliverFrameCB> callback) {
   // |callback| will be deleted when this exits.
 }
 }  // namespace
 
 // MediaStreamVideoTrack::FrameDeliverer is a helper class used for registering
 // VideoCaptureDeliverFrameCB on the main render thread to receive video frames
 // on the IO-thread.
-// Frames are only delivered to the sinks if the track is enabled.
+// Frames are only delivered to the sinks if the track is enabled. If the track
+// is disabled, a black frame is instead forwarded to the sinks at the same
+// frame rate.
 class MediaStreamVideoTrack::FrameDeliverer
     : public base::RefCountedThreadSafe<FrameDeliverer> {
  public:
   FrameDeliverer(
       const scoped_refptr<base::MessageLoopProxy>& io_message_loop,
       bool enabled);
 
   void SetEnabled(bool enabled);
 
   // Add |callback| to receive video frames on the IO-thread.
@@ skipping 13 matching lines @@
                         const base::TimeTicks& estimated_capture_time);
 
  private:
   friend class base::RefCountedThreadSafe<FrameDeliverer>;
   virtual ~FrameDeliverer();
   void AddCallbackOnIO(void* id, const VideoCaptureDeliverFrameCB& callback);
   void RemoveCallbackOnIO(
       void* id, const scoped_refptr<base::MessageLoopProxy>& message_loop);
 
   void SetEnabledOnIO(bool enabled);
+  // Returns |black_frame_| where the size and time stamp is set to the same as
+  // as in |reference_frame|.
+  const scoped_refptr<media::VideoFrame>& GetBlackFrame(
+      const scoped_refptr<media::VideoFrame>& reference_frame);
 
   // Used to DCHECK that AddCallback and RemoveCallback are called on the main
   // render thread.
   base::ThreadChecker thread_checker_;
   scoped_refptr<base::MessageLoopProxy> io_message_loop_;
 
   bool enabled_;
+  scoped_refptr<media::VideoFrame> black_frame_;
 
   typedef std::pair<void*, VideoCaptureDeliverFrameCB> VideoIdCallbackPair;
   std::vector<VideoIdCallbackPair> callbacks_;
 
   DISALLOW_COPY_AND_ASSIGN(FrameDeliverer);
 };
 
 MediaStreamVideoTrack::FrameDeliverer::FrameDeliverer(
     const scoped_refptr<base::MessageLoopProxy>& io_message_loop, bool enabled)
     : io_message_loop_(io_message_loop),
@@ skipping 51 matching lines @@
   DCHECK(thread_checker_.CalledOnValidThread());
   io_message_loop_->PostTask(
       FROM_HERE,
       base::Bind(&FrameDeliverer::SetEnabledOnIO,
                  this, enabled));
 }
 
 void MediaStreamVideoTrack::FrameDeliverer::SetEnabledOnIO(bool enabled) {
   DCHECK(io_message_loop_->BelongsToCurrentThread());
   enabled_ = enabled;
+  if (enabled_)
+    black_frame_ = NULL;
 }
 
 void MediaStreamVideoTrack::FrameDeliverer::DeliverFrameOnIO(
     const scoped_refptr<media::VideoFrame>& frame,
     const media::VideoCaptureFormat& format,
     const base::TimeTicks& estimated_capture_time) {
   DCHECK(io_message_loop_->BelongsToCurrentThread());
-  if (!enabled_)
-    return;
+  const scoped_refptr<media::VideoFrame>& video_frame =
+      enabled_ ? frame : GetBlackFrame(frame);
+
   for (std::vector<VideoIdCallbackPair>::iterator it = callbacks_.begin();
        it != callbacks_.end(); ++it) {
-    it->second.Run(frame, format, estimated_capture_time);
+    it->second.Run(video_frame, format, estimated_capture_time);
   }
 }
 
+const scoped_refptr<media::VideoFrame>&
+MediaStreamVideoTrack::FrameDeliverer::GetBlackFrame(
+    const scoped_refptr<media::VideoFrame>& reference_frame) {
+  DCHECK(io_message_loop_->BelongsToCurrentThread());
+  if (!black_frame_ ||
+      black_frame_->natural_size() != reference_frame->natural_size())
+    black_frame_ =
+        media::VideoFrame::CreateBlackFrame(reference_frame->natural_size());
+
+  black_frame_->set_timestamp(reference_frame->timestamp());
+  return black_frame_;
+}
+
 // static
 blink::WebMediaStreamTrack MediaStreamVideoTrack::CreateVideoTrack(
     MediaStreamVideoSource* source,
     const blink::WebMediaConstraints& constraints,
     const MediaStreamVideoSource::ConstraintsCallback& callback,
     bool enabled) {
   blink::WebMediaStreamTrack track;
   track.initialize(source->owner());
   track.setExtraData(new MediaStreamVideoTrack(source,
                                                constraints,
@@ skipping 84 matching lines @@
   DCHECK(thread_checker_.CalledOnValidThread());
   muted_state_ = muted_state;
 }
 
 bool MediaStreamVideoTrack::GetMutedState(void) const {
   DCHECK(thread_checker_.CalledOnValidThread());
   return muted_state_;
 }
 
 }  // namespace content