RTCCertificate.getFingerprints added (exposed to the web)

content/renderer/media/rtc_certificate.cc

 // Copyright (c) 2015 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "content/renderer/media/rtc_certificate.h"
 
+#include <vector>
+
 #include "base/memory/ptr_util.h"
+#include "third_party/webrtc/base/sslidentity.h"
 #include "url/gurl.h"
 
 namespace content {
 
 RTCCertificate::RTCCertificate(
     const rtc::scoped_refptr<rtc::RTCCertificate>& certificate)
     : certificate_(certificate) {
   DCHECK(certificate_);
 }
 
 RTCCertificate::~RTCCertificate() {
 }
 
 std::unique_ptr<blink::WebRTCCertificate> RTCCertificate::ShallowCopy() const {
   return base::WrapUnique(new RTCCertificate(certificate_));
 }
 
 uint64_t RTCCertificate::Expires() const {
   return certificate_->Expires();
 }
 
+blink::WebVector<blink::WebRTCDtlsFingerprint> RTCCertificate::Fingerprints()
+    const {
+  std::vector<blink::WebRTCDtlsFingerprint> fingerprints;
+  std::unique_ptr<rtc::SSLCertificateStats> first_certificate_stats =
+      certificate_->identity()->certificate().GetStats();
+  for (rtc::SSLCertificateStats* certificate_stats =
+           first_certificate_stats.get();
+       certificate_stats; certificate_stats = certificate_stats->issuer.get()) {
+    fingerprints.push_back(blink::WebRTCDtlsFingerprint(
+        blink::WebString::FromUTF8(certificate_stats->fingerprint_algorithm),
+        blink::WebString::FromUTF8(certificate_stats->fingerprint)));
+  }
+  return blink::WebVector<blink::WebRTCDtlsFingerprint>(fingerprints);

[Guido Urdaneta, 2017/04/19 12:20:42]

Is there a way to know the number of fingerprints in advance so that you can
void the std::vector and this copy?

[hbos_chromium, 2017/04/20 09:07:09]

I'd have to count it with another for-loop which is messier code, and WebVector
can't change size after construction so I'd have to default-initialize |size|
WebRTCDtlsFingerprints meaning I'd have to add a parameterless constructor.

I opt not to change this code, the copying should be fine because 1) typically
there is only one fingerprint, if multiple it's a tiny number and 2) copying
fingerprints is cheap because copying WebStrings (which is all it contains) is
cheap.

[Guido Urdaneta, 2017/04/20 10:20:03]

Acknowledged.

+}
+
 blink::WebRTCCertificatePEM RTCCertificate::ToPEM() const {
   rtc::RTCCertificatePEM pem = certificate_->ToPEM();
   return blink::WebRTCCertificatePEM(
       blink::WebString::FromUTF8(pem.private_key()),
       blink::WebString::FromUTF8(pem.certificate()));
 }
 
 bool RTCCertificate::Equals(const blink::WebRTCCertificate& other) const {
   return *certificate_ ==
          *static_cast<const RTCCertificate&>(other).certificate_;
 }
 
 const rtc::scoped_refptr<rtc::RTCCertificate>&
 RTCCertificate::rtcCertificate() const {
   return certificate_;
 }
 
 }  // namespace content