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/strings/utf_string_conversions.h"
+#include "content/common/media/media_stream_track_metrics_host_messages.h"
 #include "content/renderer/media/media_stream.h"
 #include "content/renderer/media/media_stream_dependency_factory.h"
+#include "content/renderer/render_thread_impl.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),
       NON_EXPORTED_BASE(public base::NonThreadSafe) {
  public:
@@ skipping 11 matching lines @@
   // webrtc::ObserverInterface implementation.
   virtual void OnChanged() OVERRIDE;
 
   webrtc::MediaStreamTrackInterface::TrackState state_;
   scoped_refptr<webrtc::MediaStreamTrackInterface> webrtc_track_;
   blink::WebMediaStreamTrack webkit_track_;
 
   DISALLOW_COPY_AND_ASSIGN(RemoteMediaStreamTrackObserver);
 };
 
+// A track might participate in different WebMediaStreams and will

[perkj_chrome, 2014/03/12 07:12:40]

Can you please update the comment in metric_host.h as well to say what the id is
in AddTrack.

[Jói, 2014/03/12 08:50:04]

Will do.

+// have the same ID in each. So a unique ID for a track is the
+// MediaStream ID plus the track ID. We add a separator that will not
+// occur in either ID.
+std::string MakeUniqueTrackId(blink::WebMediaStreamTrack* track) {
+  return track->stream().id().utf8() + " " + track->id().utf8();

[perkj_chrome, 2014/03/12 07:12:40]

oh- I did not now that there was such a back pointer. That is wrong and I am
sure Tommy will remove it unless he just did yesterday. You can not have a back
pointer since the same track can be in multiple streams now. I think you will
have to provide the stream or the stream label to the
RemoteMediaStreamTrackObserver when its created.

[Jói, 2014/03/12 08:50:04]

Since all I really need is a unique identity per observer per renderer process
(and note that the host on the browser side is per renderer process), I can
simply use the value of the 'this' pointer. Will switch to that, it keeps things
a lot simpler.

+}
+
 }  // namespace content
 
 namespace {
 
 void InitializeWebkitTrack(webrtc::MediaStreamTrackInterface* track,
                            blink::WebMediaStreamTrack* webkit_track,
                            blink::WebMediaStreamSource::Type type) {
   blink::WebMediaStreamSource webkit_source;
   blink::WebString webkit_track_id(base::UTF8ToUTF16(track->id()));
 
@@ skipping 19 matching lines @@
 
 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) {
   webrtc_track->RegisterObserver(this);
+
+  // We need to mirror the lifetime state for tracks to the browser
+  // process so that the duration of tracks can be accurately
+  // reported, because of RenderProcessHost::FastShutdownIfPossible,
+  // which in many cases will simply kill the renderer process.
+  RenderThreadImpl::current()->Send(new MediaStreamTrackMetricsHost_AddTrack(
+      MakeUniqueTrackId(&webkit_track_),
+      webkit_track_.source().type() == blink::WebMediaStreamSource::TypeAudio,
+      true));
 }
 
 RemoteMediaStreamTrackObserver::~RemoteMediaStreamTrackObserver() {
+  RenderThreadImpl::current()->Send(new MediaStreamTrackMetricsHost_RemoveTrack(
+      MakeUniqueTrackId(&webkit_track_)));
+
   webrtc_track_->UnregisterObserver(this);
 }
 
 void RemoteMediaStreamTrackObserver::OnChanged() {
   DCHECK(CalledOnValidThread());
 
   webrtc::MediaStreamTrackInterface::TrackState state = webrtc_track_->state();
   if (state == state_)
     return;
 
@@ skipping 115 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