MediaStreamTrackMetrics simplified to observe tracks, not streams.

Prior to this CL, MediaStreamTrackMetrics hooked up to streams, tracking
not only all of the streams' tracks (CONNECTED/DISCONNECTED) but also
any tracks that might be added or removed from the stream.

This has not been necessary to do for a long time, since the RTP Media
APIs are track-based, not stream-based, and the legacy
addStream()-streams are shimmed on top of addTrack(). Adding a track to
such a stream causes addTrack(), and there is no need for the
MediaStreamTrackMetrics class to observe the streams.

With this CL, MediaStreamTrackMetrics only care about tracks (direction,
kind and id). This also covers the Unified Plan use case of tracks not
necessarily belonging to any stream.

There is room for improvements in this area, such as counting tracks
added through replaceTrack(), but that should be handled separately.
This CL removes the dependency on streams which unblocks
RTCRtpTransceiver/Unified Plan work.

Bug: 810708, 777617
Change-Id: I347e729560717be83b7b1a3571f25a8497d65e46
Reviewed-on: https://chromium-review.googlesource.com/1117691Reviewed-by: Harald Alvestrand <hta@chromium.org>
Commit-Queue: Henrik Boström <hbos@chromium.org>
Cr-Commit-Position: refs/heads/master@{#572521}

content/renderer/media/webrtc/media_stream_track_metrics.h

@@ -15,10 +15,6 @@
 #include "content/common/media/media_stream.mojom.h"
 #include "third_party/webrtc/api/peerconnectioninterface.h"
 
-namespace webrtc {
-class MediaStreamInterface;
-}
-
 namespace content {
 
 class MediaStreamTrackMetricsObserver;
@@ -36,19 +32,16 @@ class CONTENT_EXPORT MediaStreamTrackMetrics {
   explicit MediaStreamTrackMetrics();
   ~MediaStreamTrackMetrics();
 
-  enum StreamType { SENT_STREAM, RECEIVED_STREAM };
-
-  enum TrackType { AUDIO_TRACK, VIDEO_TRACK };
-
-  enum LifetimeEvent { CONNECTED, DISCONNECTED };
+  enum class Direction { kSend, kReceive };
+  enum class Kind { kAudio, kVideo };
+  enum class LifetimeEvent { kConnected, kDisconnected };
 
-  // Starts tracking lifetimes of all the tracks in |stream| and any
-  // tracks added or removed to/from the stream until |RemoveStream|
-  // is called or this object's lifetime ends.
-  void AddStream(StreamType type, webrtc::MediaStreamInterface* stream);
+  // Starts tracking the lifetime of the track until |RemoveTrack| is called
+  // or this object's lifetime ends.
+  void AddTrack(Direction direction, Kind kind, const std::string& track_id);
 
-  // Stops tracking lifetimes of tracks in |stream|.
-  void RemoveStream(StreamType type, webrtc::MediaStreamInterface* stream);
+  // Stops tracking the lifetime of the track.
+  void RemoveTrack(Direction direction, Kind kind, const std::string& track_id);
 
   // Called to indicate changes in the ICE connection state for the
   // PeerConnection this object is associated with. Used to generate
@@ -71,9 +64,9 @@ class CONTENT_EXPORT MediaStreamTrackMetrics {
   // PeerConnection), false for local streams (sent over a
   // PeerConnection).
   virtual void SendLifetimeMessage(const std::string& track_id,
-                                   TrackType track_type,
+                                   Kind kind,
                                    LifetimeEvent lifetime_event,
-                                   StreamType stream_type);
+                                   Direction direction);
 
  protected:
   // Calls SendLifetimeMessage for |observer| depending on |ice_state_|.
@@ -86,12 +79,12 @@ class CONTENT_EXPORT MediaStreamTrackMetrics {
   // is a one-to-one relationship).
   uint64_t MakeUniqueIdImpl(uint64_t pc_id,
                             const std::string& track,
-                            StreamType stream_type);
+                            Direction direction);
 
  private:
   // Make a unique ID for the given track, that is valid while the
   // track object and the PeerConnection it is attached to both exist.
-  uint64_t MakeUniqueId(const std::string& track, StreamType stream_type);
+  uint64_t MakeUniqueId(const std::string& track_id, Direction direction);
 
   mojom::MediaStreamTrackMetricsHostPtr& GetMediaStreamTrackMetricsHost();
 

content/renderer/media/webrtc/rtc_peer_connection_handler.cc

@@ -893,6 +893,13 @@ SdpSemanticRequested GetSdpSemanticRequested(
   return kSdpSemanticRequestedDefault;
 }
 
+MediaStreamTrackMetrics::Kind MediaStreamTrackMetricsKind(
+    const blink::WebMediaStreamTrack& track) {
+  return track.Source().GetType() == blink::WebMediaStreamSource::kTypeAudio
+             ? MediaStreamTrackMetrics::Kind::kAudio
+             : MediaStreamTrackMetrics::Kind::kVideo;
+}
+
 }  // namespace
 
 // Implementation of LocalRTCStatsRequest.
@@ -1826,6 +1833,9 @@ std::unique_ptr<blink::WebRTCRtpSender> RTCPeerConnectionHandler::AddTrack(
                                         webrtc_streams);
   if (!webrtc_sender)
     return nullptr;
+  track_metrics_.AddTrack(MediaStreamTrackMetrics::Direction::kSend,
+                          MediaStreamTrackMetricsKind(track),
+                          track.Id().Utf8());
   DCHECK(FindSender(RTCRtpSender::getId(webrtc_sender)) == rtp_senders_.end());
   rtp_senders_.push_back(std::make_unique<RTCRtpSender>(
       native_peer_connection_, task_runner_, signaling_thread(),
@@ -1840,8 +1850,6 @@ std::unique_ptr<blink::WebRTCRtpSender> RTCPeerConnectionHandler::AddTrack(
     if (GetLocalStreamUsageCount(rtp_senders_,
                                  stream_ref->adapter().web_stream()) == 1u) {
       PerSessionWebRTCAPIMetrics::GetInstance()->IncrementStreamCounter();
-      track_metrics_.AddStream(MediaStreamTrackMetrics::SENT_STREAM,
-                               stream_ref->adapter().webrtc_stream().get());
     }
   }
   return rtp_senders_.back()->ShallowCopy();
@@ -1850,11 +1858,15 @@ std::unique_ptr<blink::WebRTCRtpSender> RTCPeerConnectionHandler::AddTrack(
 bool RTCPeerConnectionHandler::RemoveTrack(blink::WebRTCRtpSender* web_sender) {
   DCHECK(task_runner_->RunsTasksInCurrentSequence());
   TRACE_EVENT0("webrtc", "RTCPeerConnectionHandler::RemoveTrack");
+  auto web_track = web_sender->Track();
   auto it = FindSender(web_sender->Id());
   if (it == rtp_senders_.end())
     return false;
   if (!(*it)->RemoveFromPeerConnection(native_peer_connection_.get()))
     return false;
+  track_metrics_.RemoveTrack(MediaStreamTrackMetrics::Direction::kSend,
+                             MediaStreamTrackMetricsKind(web_track),
+                             web_track.Id().Utf8());
   auto stream_refs = (*it)->stream_refs();
   if (peer_connection_tracker_) {
     peer_connection_tracker_->TrackRemoveTransceiver(
@@ -1869,8 +1881,6 @@ bool RTCPeerConnectionHandler::RemoveTrack(blink::WebRTCRtpSender* web_sender) {
     if (GetLocalStreamUsageCount(rtp_senders_,
                                  stream_ref->adapter().web_stream()) == 0u) {
       PerSessionWebRTCAPIMetrics::GetInstance()->DecrementStreamCounter();
-      track_metrics_.RemoveStream(MediaStreamTrackMetrics::SENT_STREAM,
-                                  stream_ref->adapter().webrtc_stream().get());
     }
   }
   return true;
@@ -2062,7 +2072,10 @@ void RTCPeerConnectionHandler::OnAddRemoteTrack(
         remote_stream_adapter_refs) {
   DCHECK(task_runner_->RunsTasksInCurrentSequence());
   TRACE_EVENT0("webrtc", "RTCPeerConnectionHandler::OnAddRemoteTrack");
-
+  auto web_track = remote_track_adapter_ref->web_track();
+  track_metrics_.AddTrack(MediaStreamTrackMetrics::Direction::kReceive,
+                          MediaStreamTrackMetricsKind(web_track),
+                          web_track.Id().Utf8());
   for (const auto& remote_stream_adapter_ref : remote_stream_adapter_refs) {
     // New remote stream?
     if (GetRemoteStreamUsageCount(
@@ -2070,9 +2083,6 @@ void RTCPeerConnectionHandler::OnAddRemoteTrack(
             remote_stream_adapter_ref->adapter().webrtc_stream().get()) == 0) {
       // Update metrics.
       PerSessionWebRTCAPIMetrics::GetInstance()->IncrementStreamCounter();
-      track_metrics_.AddStream(
-          MediaStreamTrackMetrics::RECEIVED_STREAM,
-          remote_stream_adapter_ref->adapter().webrtc_stream().get());
     }
   }
 
@@ -2116,8 +2126,12 @@ void RTCPeerConnectionHandler::OnRemoveRemoteTrack(
           nullptr /* sender */, it->second->ShallowCopy() /* receiver */);
     }
     remote_stream_adapter_refs = it->second->StreamAdapterRefs();
+    auto receiver = it->second->ShallowCopy();
+    track_metrics_.RemoveTrack(MediaStreamTrackMetrics::Direction::kReceive,
+                               MediaStreamTrackMetricsKind(receiver->Track()),
+                               receiver->Track().Id().Utf8());
     if (!is_closed_)
-      client_->DidRemoveRemoteTrack(it->second->ShallowCopy());
+      client_->DidRemoveRemoteTrack(std::move(receiver));
     rtp_receivers_.erase(it);
   }
 
@@ -2127,9 +2141,6 @@ void RTCPeerConnectionHandler::OnRemoveRemoteTrack(
             rtp_receivers_,
             remote_stream_adapter_ref->adapter().webrtc_stream().get()) == 0) {
       // Update metrics.
-      track_metrics_.RemoveStream(
-          MediaStreamTrackMetrics::RECEIVED_STREAM,
-          remote_stream_adapter_ref->adapter().webrtc_stream().get());
       PerSessionWebRTCAPIMetrics::GetInstance()->DecrementStreamCounter();
     }
   }