RTCStatsCollector: Utilize network thread to minimize thread hops.

webrtc/api/webrtcsession.cc

Index: webrtc/api/webrtcsession.cc
diff --git a/webrtc/api/webrtcsession.cc b/webrtc/api/webrtcsession.cc
index c5582d3630b7ebdc0644f5a6738ff2bc540d6127..0c3515940b1925bc52521028b9c4c1f92f64bbf1 100644
--- a/webrtc/api/webrtcsession.cc
+++ b/webrtc/api/webrtcsession.cc
@@ -627,6 +627,24 @@ void WebRtcSession::Close() {
   media_controller_->Close();
 }
 
+std::unique_ptr<ChannelNamePairs> WebRtcSession::GetChannelNamePairs() {
+  ASSERT(signaling_thread()->IsCurrent());
+  std::unique_ptr<ChannelNamePairs> channel_name_pairs(new ChannelNamePairs());
+  if (voice_channel()) {
+    channel_name_pairs->voice = rtc::Optional<ChannelNamePair>(ChannelNamePair(
+        voice_channel()->content_name(), voice_channel()->transport_name()));
+  }
+  if (video_channel()) {
+    channel_name_pairs->video = rtc::Optional<ChannelNamePair>(ChannelNamePair(
+        video_channel()->content_name(), video_channel()->transport_name()));
+  }
+  if (data_channel()) {
+    channel_name_pairs->data = rtc::Optional<ChannelNamePair>(ChannelNamePair(
+        data_channel()->content_name(), data_channel()->transport_name()));
+  }
+  return channel_name_pairs;
+}
+
 cricket::BaseChannel* WebRtcSession::GetChannel(
     const std::string& content_name) {
   if (voice_channel() && voice_channel()->content_name() == content_name) {
@@ -1006,50 +1024,30 @@ bool WebRtcSession::GetTransportDescription(
   return true;
 }
 
-bool WebRtcSession::GetTransportStats(SessionStats* stats) {
+std::unique_ptr<SessionStats> WebRtcSession::GetSessionStats() {
   ASSERT(signaling_thread()->IsCurrent());
-  return (GetChannelTransportStats(voice_channel(), stats) &&
-          GetChannelTransportStats(video_channel(), stats) &&
-          GetChannelTransportStats(data_channel(), stats));
+  std::unique_ptr<ChannelNamePairs> channel_name_pairs = GetChannelNamePairs();
+  return GetSessionStats(*channel_name_pairs);
 }
 
-bool WebRtcSession::GetChannelTransportStats(cricket::BaseChannel* ch,
-                                             SessionStats* stats) {
-  ASSERT(signaling_thread()->IsCurrent());
-  if (!ch) {
-    // Not using this channel.
-    return true;
-  }
-
-  const std::string& content_name = ch->content_name();
-  const std::string& transport_name = ch->transport_name();
-  stats->proxy_to_transport[content_name] = transport_name;
-  if (stats->transport_stats.find(transport_name) !=
-      stats->transport_stats.end()) {
-    // Transport stats already done for this transport.
-    return true;
-  }
-
-  cricket::TransportStats tstats;
-  if (!transport_controller_->GetStats(transport_name, &tstats)) {
-    return false;
-  }
-
-  stats->transport_stats[transport_name] = tstats;
-  return true;
+std::unique_ptr<SessionStats> WebRtcSession::GetSessionStats(
+    const ChannelNamePairs& channel_name_pairs) {
+  if (network_thread()->IsCurrent())
+    return GetSessionStats_n(channel_name_pairs);
+  return network_thread()->Invoke<std::unique_ptr<SessionStats>>(
+      RTC_FROM_HERE,
+      rtc::Bind(&WebRtcSession::GetSessionStats_n, this, channel_name_pairs));
 }
 
 bool WebRtcSession::GetLocalCertificate(
     const std::string& transport_name,
     rtc::scoped_refptr<rtc::RTCCertificate>* certificate) {
-  ASSERT(signaling_thread()->IsCurrent());
   return transport_controller_->GetLocalCertificate(transport_name,
                                                     certificate);
 }
 
 std::unique_ptr<rtc::SSLCertificate> WebRtcSession::GetRemoteSSLCertificate(
     const std::string& transport_name) {
-  ASSERT(signaling_thread()->IsCurrent());
   return transport_controller_->GetRemoteSSLCertificate(transport_name);
 }
 
@@ -1749,6 +1747,46 @@ bool WebRtcSession::CreateDataChannel(const cricket::ContentInfo* content,
   return true;
 }
 
+std::unique_ptr<SessionStats> WebRtcSession::GetSessionStats_n(

[Taylor Brandstetter, 2016/12/15 01:12:53]

nit: Does this method need the channel_name_pairs argument? Or could it just
return stats for all current existing transports? Even if the channel_name_pairs
argument is needed, it seems odd that the content_name part is only used for
building the output. It could just take a list of transport names instead, and
return a list of TransportStats.

+    const ChannelNamePairs& channel_name_pairs) {
+  ASSERT(network_thread()->IsCurrent());
+  std::unique_ptr<SessionStats> session_stats(new SessionStats());
+  if (channel_name_pairs.voice) {
+    cricket::TransportStats voice_transport_stats;
+    if (!transport_controller_->GetStats(
+        channel_name_pairs.voice->transport_name, &voice_transport_stats)) {
+      return nullptr;
+    }
+    session_stats->proxy_to_transport[channel_name_pairs.voice->content_name] =
+        channel_name_pairs.voice->transport_name;
+    session_stats->transport_stats[channel_name_pairs.voice->transport_name] =
+        std::move(voice_transport_stats);
+  }
+  if (channel_name_pairs.video) {
+    cricket::TransportStats video_transport_stats;
+    if (!transport_controller_->GetStats(
+        channel_name_pairs.video->transport_name, &video_transport_stats)) {
+      return nullptr;
+    }
+    session_stats->proxy_to_transport[channel_name_pairs.video->content_name] =
+        channel_name_pairs.video->transport_name;
+    session_stats->transport_stats[channel_name_pairs.video->transport_name] =
+        std::move(video_transport_stats);
+  }
+  if (channel_name_pairs.data) {
+    cricket::TransportStats data_transport_stats;
+    if (!transport_controller_->GetStats(
+        channel_name_pairs.data->transport_name, &data_transport_stats)) {
+      return nullptr;
+    }
+    session_stats->proxy_to_transport[channel_name_pairs.data->content_name] =
+        channel_name_pairs.data->transport_name;
+    session_stats->transport_stats[channel_name_pairs.data->transport_name] =
+        std::move(data_transport_stats);
+  }
+  return session_stats;
+}
+
 void WebRtcSession::OnDtlsSetupFailure(cricket::BaseChannel*, bool rtcp) {
   SetError(ERROR_TRANSPORT,
            rtcp ? kDtlsSetupFailureRtcp : kDtlsSetupFailureRtp);