RTCCertificateStats 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"
 
 namespace webrtc {
 
 rtc::scoped_refptr<RTCStatsCollector> RTCStatsCollector::Create(
     PeerConnection* pc, int64_t cache_lifetime_us) {
   return rtc::scoped_refptr<RTCStatsCollector>(
       new rtc::RefCountedObject<RTCStatsCollector>(pc, cache_lifetime_us));
 }
 
 RTCStatsCollector::RTCStatsCollector(PeerConnection* pc,
@@ skipping 52 matching lines @@
 void RTCStatsCollector::ClearCachedStatsReport() {
   RTC_DCHECK(signaling_thread_->IsCurrent());
   cached_report_ = nullptr;
 }
 
 void RTCStatsCollector::ProducePartialResultsOnSignalingThread(
     int64_t timestamp_us) {
   RTC_DCHECK(signaling_thread_->IsCurrent());
   rtc::scoped_refptr<RTCStatsReport> report = RTCStatsReport::Create();
 
-  report->AddStats(ProducePeerConnectionStats_s(timestamp_us));
+  SessionStats session_stats;
+  if (pc_->session()->GetTransportStats(&session_stats)) {
+    ProduceCertificateStats_s(timestamp_us, session_stats, 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();
 
   // TODO(hbos): Gather stats on worker thread.
@@ skipping 44 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();
 }
 
-std::unique_ptr<RTCPeerConnectionStats>
-RTCStatsCollector::ProducePeerConnectionStats_s(int64_t timestamp_us) const {
+void RTCStatsCollector::ProduceCertificateStats_s(
+    int64_t timestamp_us, const SessionStats& session_stats,
+    RTCStatsReport* report) const {
+  RTC_DCHECK(signaling_thread_->IsCurrent());
+  for (const auto& transport : session_stats.transport_stats) {
+    rtc::scoped_refptr<rtc::RTCCertificate> local_certificate;
+    if (pc_->session()->GetLocalCertificate(
+        transport.second.transport_name, &local_certificate)) {
+      ProduceCertificateStatsFromSSLCertificateAndChain_s(
+          timestamp_us, &local_certificate->ssl_certificate(), report);
+    }
+    std::unique_ptr<rtc::SSLCertificate> remote_certificate =
+        pc_->session()->GetRemoteSSLCertificate(
+            transport.second.transport_name);
+    if (remote_certificate) {
+      ProduceCertificateStatsFromSSLCertificateAndChain_s(
+          timestamp_us, remote_certificate.get(), report);
+    }
+  }
+}
+
+void RTCStatsCollector::ProduceCertificateStatsFromSSLCertificateAndChain_s(
+    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;
+  for (rtc::SSLCertificateStats* s = ssl_stats.get(); s;
+       s = s->issuer.get()) {
+    RTCCertificateStats* 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;
+  }
+}
+
+void RTCStatsCollector::ProducePeerConnectionStats_s(
+    int64_t timestamp_us, RTCStatsReport* report) const {
   RTC_DCHECK(signaling_thread_->IsCurrent());
   // TODO(hbos): If data channels are removed from the peer connection this will
   // yield incorrect counts. Address before closing crbug.com/636818. See
   // https://w3c.github.io/webrtc-stats/webrtc-stats.html#pcstats-dict*.
   uint32_t data_channels_opened = 0;
   const std::vector<rtc::scoped_refptr<DataChannel>>& data_channels =
       pc_->sctp_data_channels();
   for (const rtc::scoped_refptr<DataChannel>& data_channel : data_channels) {
     if (data_channel->state() == DataChannelInterface::kOpen)
       ++data_channels_opened;
   }
   // 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;
-  return stats;
+  report->AddStats(std::move(stats));
 }
 
 }  // namespace webrtc