content::RTCCertificateGenerator and WebRTC-EnableWebRtcEcdsa update.

content/renderer/media/rtc_peer_connection_handler.cc

 // Copyright (c) 2012 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_peer_connection_handler.h"
 
 #include <string.h>
 
 #include <string>
 #include <utility>
@@ skipping 10 matching lines @@
 #include "base/threading/thread_task_runner_handle.h"
 #include "base/trace_event/trace_event.h"
 #include "content/public/common/content_features.h"
 #include "content/public/common/content_switches.h"
 #include "content/renderer/media/media_stream_audio_track.h"
 #include "content/renderer/media/media_stream_constraints_util.h"
 #include "content/renderer/media/media_stream_track.h"
 #include "content/renderer/media/peer_connection_tracker.h"
 #include "content/renderer/media/remote_media_stream_impl.h"
 #include "content/renderer/media/rtc_certificate.h"
+#include "content/renderer/media/rtc_certificate_generator.h"
 #include "content/renderer/media/rtc_data_channel_handler.h"
 #include "content/renderer/media/rtc_dtmf_sender_handler.h"
 #include "content/renderer/media/webrtc/peer_connection_dependency_factory.h"
 #include "content/renderer/media/webrtc/webrtc_media_stream_adapter.h"
 #include "content/renderer/media/webrtc_audio_capturer.h"
 #include "content/renderer/media/webrtc_audio_device_impl.h"
 #include "content/renderer/media/webrtc_uma_histograms.h"
 #include "content/renderer/render_thread_impl.h"
 #include "media/base/media_switches.h"
 #include "third_party/WebKit/public/platform/WebMediaConstraints.h"
@@ skipping 676 matching lines @@
       constraints, &blink::WebMediaTrackConstraintSet::voiceActivityDetection,
       &output->voice_activity_detection);
   GetConstraintValueAsBoolean(constraints,
                               &blink::WebMediaTrackConstraintSet::iceRestart,
                               &output->ice_restart);
 }
 
 base::LazyInstance<std::set<RTCPeerConnectionHandler*> >::Leaky
     g_peer_connection_handlers = LAZY_INSTANCE_INITIALIZER;
 
+void OverrideDefaultCertificateBasedOnExperiment(
+    webrtc::PeerConnectionInterface::RTCConfiguration* config) {
+  if (!config->certificates.empty())
+    return;  // A certificate has already been set up to override the default.
+  rtc::KeyType key_type;
+  if (base::FeatureList::IsEnabled(features::kWebRtcEcdsaDefault)) {
+    key_type = rtc::KT_ECDSA;
+  } else {
+    key_type = rtc::KT_RSA;
+  }
+  if (key_type != rtc::KT_DEFAULT) {

[tommi (sloooow) - chröme, 2016/05/12 12:42:56]

Can you add a static assert that ensure that KT_DEFAULT is always either
KT_ECDSA or KT_RSA?

[hbos_chromium, 2016/05/12 14:28:00]

As discussed, that is not necessary. We should make sure we get a certificate of
whatever type key_type is, regardless of KT_DEFAULT. The reason for checking for
KT_DEFAULT is that if we rely on the default code path we end up with the same
certificate that we wanted but the peer connection is doing it for us, utilizing
the the worker thread (async!), which might be beneficial. (But even if
KT_DEFAULT was "KT_CAESAR_CIPHER" this should work.)

+    rtc::scoped_refptr<rtc::RTCCertificate> certificate =

[tommi (sloooow) - chröme, 2016/05/12 12:42:56]

avoid rtc:: types

[hbos_chromium, 2016/05/12 14:28:00]

Done.

+        RTCCertificateGenerator::generateCertificateAndWait(
+            rtc::KeyParams(key_type), rtc::Optional<uint64_t>());
+    if (!certificate) {
+      // This should not happen, but if it does it is better than crashing.
+      LOG(WARNING) << "Failed to generate certificate, will rely on default "
+                      "instead.";
+    } else {
+      config->certificates.push_back(certificate);
+    }
+  }
+}
+
 }  // namespace
 
 // Implementation of LocalRTCStatsRequest.
 LocalRTCStatsRequest::LocalRTCStatsRequest(blink::WebRTCStatsRequest impl)
     : impl_(impl) {
 }
 
 LocalRTCStatsRequest::LocalRTCStatsRequest() {}
 LocalRTCStatsRequest::~LocalRTCStatsRequest() {}
 
@@ skipping 210 matching lines @@
     const blink::WebRTCConfiguration& server_configuration,
     const blink::WebMediaConstraints& options) {
   DCHECK(thread_checker_.CalledOnValidThread());
   DCHECK(frame_);
 
   peer_connection_tracker_ =
       RenderThreadImpl::current()->peer_connection_tracker()->AsWeakPtr();
 
   webrtc::PeerConnectionInterface::RTCConfiguration config;
   GetNativeRtcConfiguration(server_configuration, &config);
-
-  if (base::FeatureList::IsEnabled(features::kWebRtcEcdsaDefault)) {
-    if (config.certificates.empty()) {
-      rtc::scoped_refptr<rtc::RTCCertificate> certificate =
-          PeerConnectionDependencyFactory::GenerateDefaultCertificate();
-      config.certificates.push_back(certificate);
-    }
-  }
+  OverrideDefaultCertificateBasedOnExperiment(&config);
 
   // Choose between RTC smoothness algorithm and prerenderer smoothing.
   // Prerenderer smoothing is turned on if RTC smoothness is turned off.
   config.set_prerenderer_smoothing(
       base::CommandLine::ForCurrentProcess()->HasSwitch(
           switches::kDisableRTCSmoothnessAlgorithm));
 
   // Copy all the relevant constraints into |config|.
   CopyConstraintsIntoRtcConfiguration(options, &config);
 
@@ skipping 16 matching lines @@
   return true;
 }
 
 bool RTCPeerConnectionHandler::InitializeForTest(
     const blink::WebRTCConfiguration& server_configuration,
     const blink::WebMediaConstraints& options,
     const base::WeakPtr<PeerConnectionTracker>& peer_connection_tracker) {
   DCHECK(thread_checker_.CalledOnValidThread());
   webrtc::PeerConnectionInterface::RTCConfiguration config;
   GetNativeRtcConfiguration(server_configuration, &config);
-
-  if (base::FeatureList::IsEnabled(features::kWebRtcEcdsaDefault)) {
-    if (config.certificates.empty()) {
-      rtc::scoped_refptr<rtc::RTCCertificate> certificate =
-          PeerConnectionDependencyFactory::GenerateDefaultCertificate();
-      config.certificates.push_back(certificate);
-    }
-  }
+  OverrideDefaultCertificateBasedOnExperiment(&config);
 
   peer_connection_observer_ = new Observer(weak_factory_.GetWeakPtr());
   CopyConstraintsIntoRtcConfiguration(options, &config);
 
   native_peer_connection_ = dependency_factory_->CreatePeerConnection(
       config, nullptr, peer_connection_observer_.get());
   if (!native_peer_connection_.get()) {
     LOG(ERROR) << "Failed to initialize native PeerConnection.";
     return false;
   }
@@ skipping 776 matching lines @@
 }
 
 void RTCPeerConnectionHandler::ResetUMAStats() {
   DCHECK(thread_checker_.CalledOnValidThread());
   num_local_candidates_ipv6_ = 0;
   num_local_candidates_ipv4_ = 0;
   ice_connection_checking_start_ = base::TimeTicks();
   memset(ice_state_seen_, 0, sizeof(ice_state_seen_));
 }
 }  // namespace content