RTCStatsCollector: Utilize network thread to minimize thread hops.

webrtc/api/webrtcsession.cc

 /*
  *  Copyright 2012 The WebRTC project authors. All Rights Reserved.
  *
  *  Use of this source code is governed by a BSD-style license
  *  that can be found in the LICENSE file in the root of the source
  *  tree. An additional intellectual property rights grant can be found
  *  in the file PATENTS.  All contributing project authors may
  *  be found in the AUTHORS file in the root of the source tree.
  */
 
@@ skipping 609 matching lines @@
 
 void WebRtcSession::Close() {
   SetState(STATE_CLOSED);
   RemoveUnusedChannels(nullptr);
   ASSERT(!voice_channel_);
   ASSERT(!video_channel_);
   ASSERT(!data_channel_);
   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) {
     return voice_channel();
   }
   if (video_channel() && video_channel()->content_name() == content_name) {
     return video_channel();
   }
   if (data_channel() && data_channel()->content_name() == content_name) {
     return data_channel();
@@ skipping 392 matching lines @@
 
   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_n(
+    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_n(
+        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_n(
+        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_n(
+        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;
+}
+
 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);
 }
 
+bool WebRtcSession::GetLocalCertificate_n(
+    const std::string& transport_name,
+    rtc::scoped_refptr<rtc::RTCCertificate>* certificate) {
+  ASSERT(network_thread()->IsCurrent());
+  return transport_controller_->GetLocalCertificate_n(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);
 }
 
+std::unique_ptr<rtc::SSLCertificate> WebRtcSession::GetRemoteSSLCertificate_n(
+    const std::string& transport_name) {
+  ASSERT(network_thread()->IsCurrent());
+  return transport_controller_->GetRemoteSSLCertificate_n(transport_name);
+}
+
 bool WebRtcSession::EnableBundle(const cricket::ContentGroup& bundle) {
   const std::string* first_content_name = bundle.FirstContentName();
   if (!first_content_name) {
     LOG(LS_WARNING) << "Tried to BUNDLE with no contents.";
     return false;
   }
   const std::string& transport_name = *first_content_name;
   cricket::BaseChannel* first_channel = GetChannel(transport_name);
 
 #ifdef HAVE_QUIC
@@ skipping 1021 matching lines @@
 }
 
 void WebRtcSession::OnDtlsHandshakeError(rtc::SSLHandshakeError error) {
   if (metrics_observer_) {
     metrics_observer_->IncrementEnumCounter(
         webrtc::kEnumCounterDtlsHandshakeError, static_cast<int>(error),
         static_cast<int>(rtc::SSLHandshakeError::MAX_VALUE));
   }
 }
 }  // namespace webrtc