Add MediaStreamSource frame rate calculation to the tracker.

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/render_thread_impl.h"
 #include "content/renderer/media/media_stream_constraints_util.h"
 #include "content/renderer/media/media_stream_video_track.h"
+#include "content/renderer/media/peer_connection_tracker.h"
 #include "content/renderer/media/video_track_adapter.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";
@@ skipping 424 matching lines @@
 MediaStreamVideoSource::io_message_loop() const {
   DCHECK(CalledOnValidThread());
   return track_adapter_->io_message_loop();
 }
 
 void MediaStreamVideoSource::DoStopSource() {
   DCHECK(CalledOnValidThread());
   DVLOG(3) << "DoStopSource()";
   if (state_ == ENDED)
     return;
-  track_adapter_->StopFrameMonitoring();
   StopSourceImpl();
   state_ = ENDED;
   SetReadyState(blink::WebMediaStreamSource::ReadyStateEnded);
 }
 
 void MediaStreamVideoSource::OnSupportedFormats(
     const media::VideoCaptureFormats& formats) {
   DCHECK(CalledOnValidThread());
   DCHECK_EQ(RETRIEVING_CAPABILITIES, state_);
 
@@ skipping 50 matching lines @@
 void MediaStreamVideoSource::OnStartDone(MediaStreamRequestResult result) {
   DCHECK(CalledOnValidThread());
   DVLOG(3) << "OnStartDone({result =" << result << "})";
   if (result == MEDIA_DEVICE_OK) {
     DCHECK_EQ(STARTING, state_);
     state_ = STARTED;
     SetReadyState(blink::WebMediaStreamSource::ReadyStateLive);
 
     track_adapter_->StartFrameMonitoring(
         current_format_.frame_rate,
-        base::Bind(&MediaStreamVideoSource::SetMutedState,
+        base::Bind(&MediaStreamVideoSource::OnFrameRateCallback,
                    weak_factory_.GetWeakPtr()));
 
   } else {
     StopSource();
   }
 
   // This object can be deleted after calling FinalizeAddTrack. See comment in
   // the header file.
   FinalizeAddTrack();
 }
 
+std::string MediaStreamVideoSource::TypeName() const {
+  return "";
+}
+
 void MediaStreamVideoSource::FinalizeAddTrack() {
   DCHECK(CalledOnValidThread());
   media::VideoCaptureFormats formats;
   formats.push_back(current_format_);
 
   std::vector<RequestedConstraints> callbacks;
   callbacks.swap(requested_constraints_);
   for (std::vector<RequestedConstraints>::iterator it = callbacks.begin();
        it != callbacks.end(); ++it) {
     MediaStreamRequestResult result = MEDIA_DEVICE_OK;
@@ skipping 39 matching lines @@
   DVLOG(3) << "MediaStreamVideoSource::SetReadyState state " << state;
   DCHECK(CalledOnValidThread());
   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) {
-  DVLOG(3) << "MediaStreamVideoSource::SetMutedState state=" << muted_state;
+void MediaStreamVideoSource::OnFrameRateCallback(float framerate,
+                                                 int dropped_frames) {
   DCHECK(CalledOnValidThread());
-  if (!owner().isNull()) {
-    owner().setReadyState(muted_state
-        ? blink::WebMediaStreamSource::ReadyStateMuted
-        : blink::WebMediaStreamSource::ReadyStateLive);
+  if (owner().isNull())
+    return;
+  if(owner().readyState() == blink::WebMediaStreamSource::ReadyStateEnded) {
+    track_adapter_->StopFrameMonitoring();
+    return;
+  }
+
+  owner().setReadyState(framerate == 0
+                        ? blink::WebMediaStreamSource::ReadyStateMuted
+                        : blink::WebMediaStreamSource::ReadyStateLive);
+  const std::string id = TypeName() + " " + owner().name().utf8();
+  DVLOG(3) << "MediaStreamVideoSource::OnFrameRateCallback "
+      << id << " framerate="
+      << framerate  << " dropped_frames=" << dropped_frames
+      << " readyState "<<  owner().readyState();
+  if (RenderThreadImpl::current()) {
+    const std::string id = TypeName() + " " + owner().name().utf8();
+    RenderThreadImpl::current()->peer_connection_tracker()->TrackAddVideoStats(
+        id, framerate, dropped_frames);
   }
 }
 
 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