Add metrics to track the duration of tracks received over a PeerConnection.

content/renderer/media/remote_media_stream_impl.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/renderer/media/remote_media_stream_impl.h"
 
 #include <string>
 
 #include "base/logging.h"
+#include "base/metrics/histogram.h"
 #include "base/strings/utf_string_conversions.h"
+#include "base/time/time.h"
 #include "content/renderer/media/media_stream.h"
 #include "content/renderer/media/media_stream_dependency_factory.h"
 #include "third_party/WebKit/public/platform/WebString.h"
 
 namespace content {
 
 // RemoteMediaStreamTrackObserver is responsible for listening on change
 // notification on a remote webrtc MediaStreamTrack and notify WebKit.
 class RemoteMediaStreamTrackObserver
     : NON_EXPORTED_BASE(public webrtc::ObserverInterface),
@@ skipping 10 matching lines @@
   const blink::WebMediaStreamTrack& webkit_track() { return webkit_track_; }
 
  private:
   // webrtc::ObserverInterface implementation.
   virtual void OnChanged() OVERRIDE;
 
   webrtc::MediaStreamTrackInterface::TrackState state_;
   scoped_refptr<webrtc::MediaStreamTrackInterface> webrtc_track_;
   blink::WebMediaStreamTrack webkit_track_;
 
+  // Used to calculate duration of the track for a metric logged at
+  // destruction time.
+  base::TimeTicks creation_time_;
+
   DISALLOW_COPY_AND_ASSIGN(RemoteMediaStreamTrackObserver);
 };
 
 }  // namespace content
 
 namespace {
 
 void InitializeWebkitTrack(webrtc::MediaStreamTrackInterface* track,
                            blink::WebMediaStreamTrack* webkit_track,
                            blink::WebMediaStreamSource::Type type) {
@@ skipping 20 matching lines @@
 
 } // namespace anonymous
 
 namespace content {
 
 RemoteMediaStreamTrackObserver::RemoteMediaStreamTrackObserver(
     webrtc::MediaStreamTrackInterface* webrtc_track,
     const blink::WebMediaStreamTrack& webkit_track)
     : state_(webrtc_track->state()),
       webrtc_track_(webrtc_track),
-      webkit_track_(webkit_track) {
+      webkit_track_(webkit_track),
+      creation_time_(base::TimeTicks::Now()) {
   webrtc_track->RegisterObserver(this);
 }
 
 RemoteMediaStreamTrackObserver::~RemoteMediaStreamTrackObserver() {

[perkj_chrome, 2014/03/05 09:39:17]

If you close a tab - which I guess is very common when you quit a call- the
render process destructors don't run. Is that a problem for your history?

+  // Emit the duration of the track to a histogram (one for audio, one
+  // for video).
+  base::TimeDelta duration = base::TimeTicks::Now() - creation_time_;
+  std::string histogram_name = "WebRTC.ReceivedVideoTrackDuration";
+  if (webkit_track_.source().type() == blink::WebMediaStreamSource::TypeAudio) {
+    histogram_name = "WebRTC.ReceivedAudioTrackDuration";
+  } else {
+    DCHECK(webkit_track_.source().type() ==
+           blink::WebMediaStreamSource::TypeVideo);
+  }
+  UMA_HISTOGRAM_CUSTOM_TIMES(histogram_name,

[Ami GONE FROM CHROMIUM, 2014/03/05 08:44:27]

This is a bug - the name parameter to UMA macros must be a compile-time
constant.

[Alexei Svitkine (slow), 2014/03/05 14:23:37]

The histogram macros cache the Histogram object after the first invocation at
the call site, so while the name doesn't have to be a string literal (like it
does for actions), you do need a separate macro callsite for each distinct
histogram name you're logging.

+                             duration,
+                             base::TimeDelta::FromMilliseconds(100),
+                             base::TimeDelta::FromHours(16),
+                             50);
+
   webrtc_track_->UnregisterObserver(this);
 }
 
 void RemoteMediaStreamTrackObserver::OnChanged() {
   DCHECK(CalledOnValidThread());
 
   webrtc::MediaStreamTrackInterface::TrackState state = webrtc_track_->state();
   if (state == state_)
     return;
 
   state_ = state;
   switch (state) {
     case webrtc::MediaStreamTrackInterface::kInitializing:
       // Ignore the kInitializing state since there is no match in
       // WebMediaStreamSource::ReadyState.
       break;
     case webrtc::MediaStreamTrackInterface::kLive:
       webkit_track_.source().setReadyState(
           blink::WebMediaStreamSource::ReadyStateLive);
       break;
     case webrtc::MediaStreamTrackInterface::kEnded:
       webkit_track_.source().setReadyState(

[no longer working on chromium, 2014/03/05 20:54:09]

Joi, I am not sure, but if you move the code from the destructor to this kEnded
event, does it address Per's concern?

           blink::WebMediaStreamSource::ReadyStateEnded);
       break;
     default:
       NOTREACHED();
       break;
   }
 }
 
 RemoteMediaStreamImpl::RemoteMediaStreamImpl(
     webrtc::MediaStreamInterface* webrtc_stream)
@@ skipping 93 matching lines @@
       InitializeWebkitTrack(*it, &new_track,
                             blink::WebMediaStreamSource::TypeVideo);
       video_track_observers_.push_back(
           new RemoteMediaStreamTrackObserver(*it, new_track));
       webkit_stream_.addTrack(new_track);
     }
   }
 }
 
 }  // namespace content