Add MediaStreamSource frame rate calculation to the tracker.

content/browser/renderer_host/media/peer_connection_tracker_host.cc

 // Copyright (c) 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/browser/renderer_host/media/peer_connection_tracker_host.h"
 
 #include "base/power_monitor/power_monitor.h"
 #include "content/browser/media/webrtc_internals.h"
 #include "content/common/media/peer_connection_tracker_messages.h"
 #include "content/public/browser/render_process_host.h"
 
 namespace content {
 
 PeerConnectionTrackerHost::PeerConnectionTrackerHost(int render_process_id)
     : BrowserMessageFilter(PeerConnectionTrackerMsgStart),
       render_process_id_(render_process_id) {
 }
 
 bool PeerConnectionTrackerHost::OnMessageReceived(const IPC::Message& message) {
   bool handled = true;
 
   IPC_BEGIN_MESSAGE_MAP(PeerConnectionTrackerHost, message)
     IPC_MESSAGE_HANDLER(PeerConnectionTrackerHost_AddPeerConnection,
                         OnAddPeerConnection)
     IPC_MESSAGE_HANDLER(PeerConnectionTrackerHost_RemovePeerConnection,
                         OnRemovePeerConnection)
     IPC_MESSAGE_HANDLER(PeerConnectionTrackerHost_UpdatePeerConnection,
                         OnUpdatePeerConnection)
     IPC_MESSAGE_HANDLER(PeerConnectionTrackerHost_AddStats, OnAddStats)
     IPC_MESSAGE_HANDLER(PeerConnectionTrackerHost_GetUserMedia, OnGetUserMedia)
+    IPC_MESSAGE_HANDLER(PeerConnectionTrackerHost_AddVideoStats,
+                        OnAddVideoStats)
     IPC_MESSAGE_UNHANDLED(handled = false)
   IPC_END_MESSAGE_MAP()
   return handled;
 }
 
 void PeerConnectionTrackerHost::OverrideThreadForMessage(
     const IPC::Message& message, BrowserThread::ID* thread) {
   if (IPC_MESSAGE_CLASS(message) == PeerConnectionTrackerMsgStart)
     *thread = BrowserThread::UI;
 }
@@ skipping 59 matching lines @@
     const std::string& video_constraints) {
   WebRTCInternals::GetInstance()->OnGetUserMedia(render_process_id_,
                                                  peer_pid(),
                                                  origin,
                                                  audio,
                                                  video,
                                                  audio_constraints,
                                                  video_constraints);
 }
 
+void PeerConnectionTrackerHost::OnAddVideoStats(const std::string& video_id,
+                                                float input_frame_rate,
+                                                int number_of_dropped_frames) {
+  WebRTCInternals::GetInstance()->OnAddVideoStats(
+      peer_pid(), video_id, input_frame_rate, number_of_dropped_frames);
+}
+
 void PeerConnectionTrackerHost::OnSuspend() {
   BrowserThread::PostTask(BrowserThread::UI, FROM_HERE,
       base::Bind(&PeerConnectionTrackerHost::SendOnSuspendOnUIThread, this));
 }
 
 void PeerConnectionTrackerHost::SendOnSuspendOnUIThread() {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   content::RenderProcessHost* host =
       content::RenderProcessHost::FromID(render_process_id_);
   if (host)
     host->Send(new PeerConnectionTracker_OnSuspend());
 }
 
 }  // namespace content