RTCTransportStats added.

webrtc/api/rtcstatscollector.cc

 /*
  *  Copyright 2016 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.
  */
 
 #include "webrtc/api/rtcstatscollector.h"
 
 #include <memory>
 #include <utility>
 #include <vector>
 
 #include "webrtc/api/peerconnection.h"
 #include "webrtc/api/webrtcsession.h"
 #include "webrtc/base/checks.h"
 #include "webrtc/base/sslidentity.h"
 #include "webrtc/p2p/base/candidate.h"
 #include "webrtc/p2p/base/port.h"
 
 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;
   if (type == cricket::STUN_PORT_TYPE)
     return RTCIceCandidateType::kSrflx;
   if (type == cricket::PRFLX_PORT_TYPE)
     return RTCIceCandidateType::kPrflx;
   if (type == cricket::RELAY_PORT_TYPE)
     return RTCIceCandidateType::kRelay;
   RTC_NOTREACHED();
@@ skipping 64 matching lines @@
   cached_report_ = nullptr;
 }
 
 void RTCStatsCollector::ProducePartialResultsOnSignalingThread(
     int64_t timestamp_us) {
   RTC_DCHECK(signaling_thread_->IsCurrent());
   rtc::scoped_refptr<RTCStatsReport> report = RTCStatsReport::Create();
 
   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());
 
   AddPartialResults(report);
 }
 
 void RTCStatsCollector::ProducePartialResultsOnWorkerThread(
     int64_t timestamp_us) {
   RTC_DCHECK(worker_thread_->IsCurrent());
   rtc::scoped_refptr<RTCStatsReport> report = RTCStatsReport::Create();
@@ skipping 46 matching lines @@
   RTC_DCHECK(signaling_thread_->IsCurrent());
   RTC_DCHECK(!callbacks_.empty());
   RTC_DCHECK(cached_report_);
   for (const rtc::scoped_refptr<RTCStatsCollectorCallback>& callback :
        callbacks_) {
     callback->OnStatsDelivered(cached_report_);
   }
   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(
       int64_t timestamp_us, const SessionStats& session_stats,
       RTCStatsReport* report) const {
   RTC_DCHECK(signaling_thread_->IsCurrent());
   for (const auto& transport_stats : session_stats.transport_stats) {
     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.
 
         // TODO(hbos): Set candidate_pair_stats->transport_id. Should be ID to
         // RTCTransportStats which does not exist yet: crbug.com/653873.
 
         // TODO(hbos): There could be other candidates that are not paired with
         // anything. We don't have a complete list. Local candidates come from
         // Port objects, and prflx candidates (both local and remote) are only
@@ skipping 87 matching lines @@
   // There is always just one |RTCPeerConnectionStats| so its |id| can be a
   // constant.
   std::unique_ptr<RTCPeerConnectionStats> stats(
     new RTCPeerConnectionStats("RTCPeerConnection", timestamp_us));
   stats->data_channels_opened = data_channels_opened;
   stats->data_channels_closed = static_cast<uint32_t>(data_channels.size()) -
                                 data_channels_opened;
   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