VideoTrackAdapter: Add passing frames monitor, notify MSVCS -> MSVTrack(s)

content/renderer/media/video_track_adapter.cc

Index: content/renderer/media/video_track_adapter.cc
diff --git a/content/renderer/media/video_track_adapter.cc b/content/renderer/media/video_track_adapter.cc
index e51f8427bef23e69f86cae7de12ae5677e2bd70b..4438f72347d934067258667b0f0738c067ae3119 100644
--- a/content/renderer/media/video_track_adapter.cc
+++ b/content/renderer/media/video_track_adapter.cc
@@ -17,6 +17,11 @@ namespace content {
 
 namespace {
 
+// Amount of frame intervals to wait before considering the source as muted, for
+// the first frame and on normal conditions, respectively.

[Henrik Grunell, 2014/07/09 08:55:52]

Nit: "under normal conditions"

Why a larger number the first frame? Explain in comment.

[mcasas, 2014/07/09 12:39:35]

Done.

+const float kFirstFrameTimeoutInFrameIntervals = 100.0f;
+const float kNormalFrameTimeoutInFrameIntervals = 25.0f;
+
 // Empty method used for keeping a reference to the original media::VideoFrame
 // in VideoFrameResolutionAdapter::DeliverFrame if cropping is needed.
 // The reference to |frame| is kept in the closure that calls this method.
@@ -301,7 +306,9 @@ bool VideoTrackAdapter::VideoFrameResolutionAdapter::IsEmpty() const {
 VideoTrackAdapter::VideoTrackAdapter(
     const scoped_refptr<base::MessageLoopProxy>& io_message_loop)
     : io_message_loop_(io_message_loop),
-      renderer_task_runner_(base::MessageLoopProxy::current()) {
+      renderer_task_runner_(base::MessageLoopProxy::current()),
+      frame_counter_(0),
+      target_frame_rate_(0.0f) {
   DCHECK(io_message_loop_);
 }
 
@@ -309,19 +316,26 @@ VideoTrackAdapter::~VideoTrackAdapter() {
   DCHECK(adapters_.empty());
 }
 
-void VideoTrackAdapter::AddTrack(const MediaStreamVideoTrack* track,
-                                 VideoCaptureDeliverFrameCB frame_callback,
-                                 int max_width,
-                                 int max_height,
-                                 double min_aspect_ratio,
-                                 double max_aspect_ratio,
-                                 double max_frame_rate) {
+void VideoTrackAdapter::AddTrack(
+    const MediaStreamVideoTrack* track,
+    VideoCaptureDeliverFrameCB frame_callback,
+    int max_width,
+    int max_height,
+    double min_aspect_ratio,
+    double max_aspect_ratio,
+    double max_frame_rate,
+    double target_frame_rate,
+    const OnMutedCallback& on_muted_state_callback) {
   DCHECK(thread_checker_.CalledOnValidThread());
   io_message_loop_->PostTask(
       FROM_HERE,
       base::Bind(&VideoTrackAdapter::AddTrackOnIO,
                  this, track, frame_callback, gfx::Size(max_width, max_height),
                  min_aspect_ratio, max_aspect_ratio, max_frame_rate));
+  io_message_loop_->PostTask(
+      FROM_HERE,
+      base::Bind(&VideoTrackAdapter::StartTrackMonitoringOnIO,
+                 this, on_muted_state_callback, target_frame_rate));
 }
 
 void VideoTrackAdapter::AddTrackOnIO(
@@ -360,6 +374,21 @@ void VideoTrackAdapter::RemoveTrack(const MediaStreamVideoTrack* track) {
       base::Bind(&VideoTrackAdapter::RemoveTrackOnIO, this, track));
 }
 
+void VideoTrackAdapter::StartTrackMonitoringOnIO(
+    const OnMutedCallback& on_muted_state_callback,
+    double target_frame_rate) {
+  DCHECK(io_message_loop_->BelongsToCurrentThread());
+  DCHECK_NE(target_frame_rate, 0.0f);
+  target_frame_rate_ = target_frame_rate;
+  DVLOG(1) << "Monitoring frame creation, first (large) delay: "
+      << (kFirstFrameTimeoutInFrameIntervals / target_frame_rate_) << "s";
+  io_message_loop_->PostDelayedTask(FROM_HERE,
+       base::Bind(&VideoTrackAdapter::CheckFramesReceivedOnIO, this,
+                  on_muted_state_callback, frame_counter_),
+       base::TimeDelta::FromSecondsD(kFirstFrameTimeoutInFrameIntervals /
+                                     target_frame_rate_));
+}
+
 void VideoTrackAdapter::RemoveTrackOnIO(const MediaStreamVideoTrack* track) {
   DCHECK(io_message_loop_->BelongsToCurrentThread());
   for (FrameAdapters::iterator it = adapters_.begin();
@@ -378,10 +407,26 @@ void VideoTrackAdapter::DeliverFrameOnIO(
     const base::TimeTicks& estimated_capture_time) {
   DCHECK(io_message_loop_->BelongsToCurrentThread());
   TRACE_EVENT0("video", "VideoTrackAdapter::DeliverFrameOnIO");
+  ++frame_counter_;
   for (FrameAdapters::iterator it = adapters_.begin();
        it != adapters_.end(); ++it) {
     (*it)->DeliverFrame(frame, format, estimated_capture_time);
   }
 }
 
+void VideoTrackAdapter::CheckFramesReceivedOnIO(
+    const OnMutedCallback& set_muted_state_callback,
+    uint64 old_frame_counter_snapshot) {
+  DCHECK(io_message_loop_->BelongsToCurrentThread());
+  DVLOG_IF(1, old_frame_counter_snapshot == frame_counter_)
+      << "No frames have passed, setting source as Muted.";
+  set_muted_state_callback.Run(old_frame_counter_snapshot == frame_counter_);
+
+  io_message_loop_->PostDelayedTask(FROM_HERE,
+      base::Bind(&VideoTrackAdapter::CheckFramesReceivedOnIO, this,
+          set_muted_state_callback, frame_counter_),
+      base::TimeDelta::FromSecondsD(kNormalFrameTimeoutInFrameIntervals /
+                                    target_frame_rate_));
+}
+
 }  // namespace content