RTCTransportStats added.

webrtc/api/rtcstatscollector.cc

Index: webrtc/api/rtcstatscollector.cc
diff --git a/webrtc/api/rtcstatscollector.cc b/webrtc/api/rtcstatscollector.cc
index 5f60ea13cecadb7defc5169701e06a2d7308dc26..27e6fcab943c8fb622487fabae2fab4302c3686b 100644
--- a/webrtc/api/rtcstatscollector.cc
+++ b/webrtc/api/rtcstatscollector.cc
@@ -23,6 +23,15 @@
 
 namespace webrtc {
 
+namespace {
+
+std::string RTCIceCandidatePairStatsID(const cricket::ConnectionInfo& info) {
+  return "RTCIceCandidatePair_" + info.local_candidate.id() + "_" +
+      info.remote_candidate.id();
+}
+
+}  // namespace
+
 const char* CandidateTypeToRTCIceCandidateType(const std::string& type) {
   if (type == cricket::LOCAL_PORT_TYPE)
     return RTCIceCandidateType::kHost;
@@ -107,9 +116,12 @@ void RTCStatsCollector::ProducePartialResultsOnSignalingThread(
 
   SessionStats session_stats;
   if (pc_->session()->GetTransportStats(&session_stats)) {
-    ProduceCertificateStats_s(timestamp_us, session_stats, report.get());
-    ProduceIceCandidateAndPairStats_s(timestamp_us, session_stats,
-                                      report.get());
+    std::map<std::string, CertificateStatsPair> transport_certificates =
+        ProduceCertificateStats_s(timestamp_us, session_stats, report.get());
+    ProduceIceCandidateAndPairStats_s(
+        timestamp_us, session_stats, report.get());
+    ProduceTransportStats_s(
+        timestamp_us, session_stats, transport_certificates, report.get());
   }
   ProducePeerConnectionStats_s(timestamp_us, report.get());
 
@@ -176,46 +188,63 @@ void RTCStatsCollector::DeliverCachedReport() {
   callbacks_.clear();
 }
 
-void RTCStatsCollector::ProduceCertificateStats_s(
+std::map<std::string, RTCStatsCollector::CertificateStatsPair>
+RTCStatsCollector::ProduceCertificateStats_s(

[hta-webrtc, 2016/10/12 22:52:35]

I don't like this function. It's doing two things, one of which is like all the
other functions named like this, the other one isn't.

Can we break it up into an internal function "map =
PrepareCertificateStatsMap()" and ProduceCertificateStats_s(map) so that the two
functions are clearly separated?

[hbos, 2016/10/17 19:33:13]

Yes, that's much nicer. Done.

     int64_t timestamp_us, const SessionStats& session_stats,
     RTCStatsReport* report) const {
   RTC_DCHECK(signaling_thread_->IsCurrent());
+  std::map<std::string, CertificateStatsPair> transport_certificates;
   for (const auto& transport_stats : session_stats.transport_stats) {
+    CertificateStatsPair certificate_stats_pair;
     rtc::scoped_refptr<rtc::RTCCertificate> local_certificate;
     if (pc_->session()->GetLocalCertificate(
         transport_stats.second.transport_name, &local_certificate)) {
-      ProduceCertificateStatsFromSSLCertificateAndChain_s(
-          timestamp_us, local_certificate->ssl_certificate(), report);
+      certificate_stats_pair.local =
+          ProduceCertificateStatsFromSSLCertificateAndChain_s(
+              timestamp_us, local_certificate->ssl_certificate(), report);
     }
     std::unique_ptr<rtc::SSLCertificate> remote_certificate =
         pc_->session()->GetRemoteSSLCertificate(
             transport_stats.second.transport_name);
     if (remote_certificate) {
-      ProduceCertificateStatsFromSSLCertificateAndChain_s(
-          timestamp_us, *remote_certificate.get(), report);
+      certificate_stats_pair.remote =
+          ProduceCertificateStatsFromSSLCertificateAndChain_s(
+              timestamp_us, *remote_certificate.get(), report);
+    }
+    if (certificate_stats_pair.local && certificate_stats_pair.remote) {
+      transport_certificates.insert(
+          std::make_pair(transport_stats.second.transport_name,
+                         std::move(certificate_stats_pair)));
     }
   }
+  return transport_certificates;
 }
 
-void RTCStatsCollector::ProduceCertificateStatsFromSSLCertificateAndChain_s(
+RTCCertificateStats*
+RTCStatsCollector::ProduceCertificateStatsFromSSLCertificateAndChain_s(

[hta-webrtc, 2016/10/12 22:52:35]

This one too is now dual-function.

[hbos, 2016/10/17 19:33:13]

Done.

     int64_t timestamp_us, const rtc::SSLCertificate& certificate,
     RTCStatsReport* report) const {
   RTC_DCHECK(signaling_thread_->IsCurrent());
   std::unique_ptr<rtc::SSLCertificateStats> ssl_stats =
       certificate.GetStats();
-  RTCCertificateStats* prev_stats = nullptr;
+  RTCCertificateStats* first_certificate_stats = nullptr;
+  RTCCertificateStats* prev_certificate_stats = nullptr;
   for (rtc::SSLCertificateStats* s = ssl_stats.get(); s;
        s = s->issuer.get()) {
-    RTCCertificateStats* stats = new RTCCertificateStats(
+    RTCCertificateStats* certificate_stats = new RTCCertificateStats(
         "RTCCertificate_" + s->fingerprint, timestamp_us);
-    stats->fingerprint = s->fingerprint;
-    stats->fingerprint_algorithm = s->fingerprint_algorithm;
-    stats->base64_certificate = s->base64_certificate;
-    if (prev_stats)
-      prev_stats->issuer_certificate_id = stats->id();
-    report->AddStats(std::unique_ptr<RTCCertificateStats>(stats));
-    prev_stats = stats;
+    certificate_stats->fingerprint = s->fingerprint;
+    certificate_stats->fingerprint_algorithm = s->fingerprint_algorithm;
+    certificate_stats->base64_certificate = s->base64_certificate;
+    if (prev_certificate_stats)
+      prev_certificate_stats->issuer_certificate_id = certificate_stats->id();
+    report->AddStats(std::unique_ptr<RTCCertificateStats>(certificate_stats));
+    if (!first_certificate_stats)
+      first_certificate_stats = certificate_stats;
+    prev_certificate_stats = certificate_stats;
   }
+  RTC_DCHECK(first_certificate_stats);
+  return first_certificate_stats;
 }
 
 void RTCStatsCollector::ProduceIceCandidateAndPairStats_s(
@@ -226,10 +255,9 @@ void RTCStatsCollector::ProduceIceCandidateAndPairStats_s(
     for (const auto& channel_stats : transport_stats.second.channel_stats) {
       for (const cricket::ConnectionInfo& info :
            channel_stats.connection_infos) {
-        const std::string& id = "RTCIceCandidatePair_" +
-            info.local_candidate.id() + "_" + info.remote_candidate.id();
         std::unique_ptr<RTCIceCandidatePairStats> candidate_pair_stats(
-            new RTCIceCandidatePairStats(id, timestamp_us));
+            new RTCIceCandidatePairStats(RTCIceCandidatePairStatsID(info),
+                                         timestamp_us));
 
         // TODO(hbos): Set all of the |RTCIceCandidatePairStats|'s members,
         // crbug.com/633550.
@@ -337,4 +365,40 @@ void RTCStatsCollector::ProducePeerConnectionStats_s(
   report->AddStats(std::move(stats));
 }
 
+void RTCStatsCollector::ProduceTransportStats_s(
+    int64_t timestamp_us, const SessionStats& session_stats,
+    const std::map<std::string, CertificateStatsPair>& transport_certificates,
+    RTCStatsReport* report) const {
+  RTC_DCHECK(signaling_thread_->IsCurrent());
+  for (const auto& transport : session_stats.transport_stats) {
+    std::unique_ptr<RTCTransportStats> transport_stats(
+        new RTCTransportStats("RTCTransport_" + transport.second.transport_name,
+                              timestamp_us));
+    transport_stats->bytes_sent = 0;
+    transport_stats->bytes_received = 0;
+    transport_stats->active_connection = false;
+    for (const auto& channel_stats : transport.second.channel_stats) {
+      for (const cricket::ConnectionInfo& info :
+           channel_stats.connection_infos) {
+        *transport_stats->bytes_sent += info.sent_total_bytes;
+        *transport_stats->bytes_received += info.recv_total_bytes;
+        if (info.best_connection) {
+          transport_stats->active_connection = true;
+          transport_stats->selected_candidate_pair_id =
+              RTCIceCandidatePairStatsID(info);
+        }
+      }
+    }
+    // TODO(hbos): Set transport_stats->rtcp_transport_stats_id.
+    // crbug.com/653873
+    const auto& it = transport_certificates.find(
+        transport.second.transport_name);
+    if (it != transport_certificates.end()) {
+      transport_stats->local_certificate_id = it->second.local->id();
+      transport_stats->remote_certificate_id = it->second.remote->id();;
+    }
+    report->AddStats(std::move(transport_stats));
+  }
+}
+
 }  // namespace webrtc