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

content/renderer/media/media_stream_video_source.cc

 // Copyright 2014 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_source.h"
 
 #include <algorithm>
 #include <limits>
 #include <string>
 
 #include "base/debug/trace_event.h"
 #include "base/logging.h"
 #include "base/strings/string_number_conversions.h"
 #include "content/child/child_process.h"
 #include "content/renderer/media/media_stream_constraints_util.h"
 #include "content/renderer/media/media_stream_video_track.h"
 #include "content/renderer/media/video_track_adapter.h"
+#include "media/base/bind_to_current_loop.h"
 
 namespace content {
 
 // Constraint keys. Specified by draft-alvestrand-constraints-resolution-00b
 const char MediaStreamVideoSource::kMinAspectRatio[] = "minAspectRatio";
 const char MediaStreamVideoSource::kMaxAspectRatio[] = "maxAspectRatio";
 const char MediaStreamVideoSource::kMaxWidth[] = "maxWidth";
 const char MediaStreamVideoSource::kMinWidth[] = "minWidth";
 const char MediaStreamVideoSource::kMaxHeight[] = "maxHeight";
 const char MediaStreamVideoSource::kMinHeight[] = "minHeight";
@@ skipping 315 matching lines @@
 bool MediaStreamVideoSource::IsConstraintSupported(const std::string& name) {
   for (size_t i = 0; i < arraysize(kSupportedConstraints); ++i) {
     if (kSupportedConstraints[i] == name)
       return true;
   }
   return false;
 }
 
 MediaStreamVideoSource::MediaStreamVideoSource()
     : state_(NEW),
+      muted_state_(false),
       track_adapter_(new VideoTrackAdapter(
           ChildProcess::current()->io_message_loop_proxy())),
       weak_factory_(this) {
 }
 
 MediaStreamVideoSource::~MediaStreamVideoSource() {
 }
 
 void MediaStreamVideoSource::AddTrack(
     MediaStreamVideoTrack* track,
@@ skipping 182 matching lines @@
       int max_height;
       GetDesiredMaxWidthAndHeight(it->constraints, &max_width, &max_height);
       double max_aspect_ratio;
       double min_aspect_ratio;
       GetDesiredMinAndMaxAspectRatio(it->constraints,
                                      &min_aspect_ratio,
                                      &max_aspect_ratio);
       double max_frame_rate = 0.0f;
       GetConstraintValueAsDouble(it->constraints,
                                  kMaxFrameRate, &max_frame_rate);
+
+      VideoTrackAdapter::OnMutedCallback on_mute_callback =
+          media::BindToCurrentLoop(base::Bind(
+              &MediaStreamVideoSource::SetMutedState,
+              weak_factory_.GetWeakPtr()));
       track_adapter_->AddTrack(it->track, it->frame_callback,
                                max_width, max_height,
                                min_aspect_ratio, max_aspect_ratio,
-                               max_frame_rate);
+                               max_frame_rate, current_format_.frame_rate,
+                               on_mute_callback);
     }
 
     DVLOG(3) << "FinalizeAddTrack() success " << success;
 
     if (!it->callback.is_null())
       it->callback.Run(this, success);
   }
 }
 
 void MediaStreamVideoSource::SetReadyState(
     blink::WebMediaStreamSource::ReadyState state) {
   DVLOG(3) << "MediaStreamVideoSource::SetReadyState state " << state;
   if (!owner().isNull()) {
     owner().setReadyState(state);
   }
   for (std::vector<MediaStreamVideoTrack*>::iterator it = tracks_.begin();
        it != tracks_.end(); ++it) {
     (*it)->OnReadyStateChanged(state);
   }
 }
 
+void MediaStreamVideoSource::SetMutedState(bool muted_state) {
+  DCHECK(CalledOnValidThread());
+  DVLOG(3) << "MediaStreamVideoSource::SetMutedState state=" << muted_state;
+  // WebMediaStreamSource doesn't have a muted state, the tracks do.
+  for (std::vector<MediaStreamVideoTrack*>::iterator it = tracks_.begin();
+       it != tracks_.end(); ++it) {
+    (*it)->SetMutedState(muted_state);
+  }
+}
+
 MediaStreamVideoSource::RequestedConstraints::RequestedConstraints(
     MediaStreamVideoTrack* track,
     const VideoCaptureDeliverFrameCB& frame_callback,
     const blink::WebMediaConstraints& constraints,
     const ConstraintsCallback& callback)
     : track(track),
       frame_callback(frame_callback),
       constraints(constraints),
       callback(callback) {
 }
 
 MediaStreamVideoSource::RequestedConstraints::~RequestedConstraints() {
 }
 
 }  // namespace content