Replacing DtlsIdentityStoreInterface with RTCCertificateGeneratorInterface.

webrtc/api/peerconnectionfactory.cc

 /*
  *  Copyright 2004 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.
  */
 
@@ skipping 18 matching lines @@
 #include "webrtc/media/engine/webrtcvideodecoderfactory.h"
 #include "webrtc/media/engine/webrtcvideoencoderfactory.h"
 #include "webrtc/modules/audio_device/include/audio_device.h"
 #include "webrtc/p2p/base/basicpacketsocketfactory.h"
 #include "webrtc/p2p/client/basicportallocator.h"
 
 namespace webrtc {
 
 namespace {
 
-// Passes down the calls to |store_|. See usage in CreatePeerConnection.
-class DtlsIdentityStoreWrapper : public DtlsIdentityStoreInterface {
+// Passes down the calls to |cert_generator_|. See usage in
+// |CreatePeerConnection|.
+class RTCCertificateGeneratorWrapper
+    : public rtc::RTCCertificateGeneratorInterface {
  public:
-  DtlsIdentityStoreWrapper(
-      const rtc::scoped_refptr<RefCountedDtlsIdentityStore>& store)
-      : store_(store) {
-    RTC_DCHECK(store_);
+  RTCCertificateGeneratorWrapper(
+      const rtc::scoped_refptr<RefCountedRTCCertificateGenerator>& cert_gen)
+      : cert_generator_(cert_gen) {
+    RTC_DCHECK(cert_generator_);
   }
 
-  void RequestIdentity(
+  void GenerateCertificateAsync(
       const rtc::KeyParams& key_params,
       const rtc::Optional<uint64_t>& expires_ms,
-      const rtc::scoped_refptr<webrtc::DtlsIdentityRequestObserver>&
-          observer) override {
-    store_->RequestIdentity(key_params, expires_ms, observer);
+      const rtc::scoped_refptr<rtc::RTCCertificateGeneratorCallback>& callback)
+          override {
+    cert_generator_->GenerateCertificateAsync(key_params, expires_ms, callback);
   }
 
  private:
-  rtc::scoped_refptr<RefCountedDtlsIdentityStore> store_;
+  rtc::scoped_refptr<RefCountedRTCCertificateGenerator> cert_generator_;
 };
 
 }  // anonymous namespace
 
 rtc::scoped_refptr<PeerConnectionFactoryInterface>
 CreatePeerConnectionFactory() {
   rtc::scoped_refptr<PeerConnectionFactory> pc_factory(
       new rtc::RefCountedObject<PeerConnectionFactory>());
 
   RTC_CHECK(rtc::Thread::Current() == pc_factory->signaling_thread());
@@ skipping 66 matching lines @@
   // TODO: Currently there is no way creating an external adm in
   // libjingle source tree. So we can 't currently assert if this is NULL.
   // ASSERT(default_adm != NULL);
 }
 
 PeerConnectionFactory::~PeerConnectionFactory() {
   RTC_DCHECK(signaling_thread_->IsCurrent());
   channel_manager_.reset(nullptr);
 
   // Make sure |worker_thread_| and |signaling_thread_| outlive
-  // |dtls_identity_store_|, |default_socket_factory_| and
+  // |cert_generator_|, |default_socket_factory_| and
   // |default_network_manager_|.
-  dtls_identity_store_ = nullptr;
+  cert_generator_ = nullptr;
   default_socket_factory_ = nullptr;
   default_network_manager_ = nullptr;
 
   if (owns_ptrs_) {
     if (wraps_current_thread_)
       rtc::ThreadManager::Instance()->UnwrapCurrentThread();
     delete worker_thread_;
     delete network_thread_;
   }
 }
@@ skipping 20 matching lines @@
       &PeerConnectionFactory::CreateMediaEngine_w, this));
 
   channel_manager_.reset(new cricket::ChannelManager(
       media_engine, worker_thread_, network_thread_));
 
   channel_manager_->SetVideoRtxEnabled(true);
   if (!channel_manager_->Init()) {
     return false;
   }
 
-  dtls_identity_store_ =
-      new RefCountedDtlsIdentityStore(signaling_thread_, network_thread_);
+  cert_generator_ =
+      new RefCountedRTCCertificateGenerator(signaling_thread_, network_thread_);
 
   return true;
 }
 
 rtc::scoped_refptr<AudioSourceInterface>
 PeerConnectionFactory::CreateAudioSource(
     const MediaConstraintsInterface* constraints) {
   RTC_DCHECK(signaling_thread_->IsCurrent());
   rtc::scoped_refptr<LocalAudioSource> source(
       LocalAudioSource::Create(options_, constraints));
@@ skipping 49 matching lines @@
 void PeerConnectionFactory::StopRtcEventLog() {
   RTC_DCHECK(signaling_thread_->IsCurrent());
   channel_manager_->StopRtcEventLog();
 }
 
 rtc::scoped_refptr<PeerConnectionInterface>
 PeerConnectionFactory::CreatePeerConnection(
     const PeerConnectionInterface::RTCConfiguration& configuration_in,
     const MediaConstraintsInterface* constraints,
     std::unique_ptr<cricket::PortAllocator> allocator,
-    std::unique_ptr<DtlsIdentityStoreInterface> dtls_identity_store,
+    std::unique_ptr<rtc::RTCCertificateGeneratorInterface> cert_generator,
     PeerConnectionObserver* observer) {
   RTC_DCHECK(signaling_thread_->IsCurrent());
 
   // We merge constraints and configuration into a single configuration.
   PeerConnectionInterface::RTCConfiguration configuration = configuration_in;
   CopyConstraintsIntoRtcConfiguration(constraints, &configuration);
 
   return CreatePeerConnection(configuration, std::move(allocator),
-                              std::move(dtls_identity_store), observer);
+                              std::move(cert_generator), observer);
 }
 
 rtc::scoped_refptr<PeerConnectionInterface>
 PeerConnectionFactory::CreatePeerConnection(
     const PeerConnectionInterface::RTCConfiguration& configuration,
     std::unique_ptr<cricket::PortAllocator> allocator,
-    std::unique_ptr<DtlsIdentityStoreInterface> dtls_identity_store,
+    std::unique_ptr<rtc::RTCCertificateGeneratorInterface> cert_generator,
     PeerConnectionObserver* observer) {
   RTC_DCHECK(signaling_thread_->IsCurrent());
 
-  if (!dtls_identity_store.get()) {
-    // Because |pc|->Initialize takes ownership of the store we need a new
+  if (!cert_generator.get()) {
+    // Because |pc|->Initialize takes ownership of the generator we need a new
     // wrapper object that can be deleted without deleting the underlying
-    // |dtls_identity_store_|, protecting it from being deleted multiple times.
-    dtls_identity_store.reset(
-        new DtlsIdentityStoreWrapper(dtls_identity_store_));
+    // |cert_generator_|, protecting it from being deleted multiple times.
+    cert_generator.reset(
+        new RTCCertificateGeneratorWrapper(cert_generator_));
   }
 
   if (!allocator) {
     allocator.reset(new cricket::BasicPortAllocator(
         default_network_manager_.get(), default_socket_factory_.get()));
   }
   network_thread_->Invoke<void>(
       rtc::Bind(&cricket::PortAllocator::SetNetworkIgnoreMask, allocator.get(),
                 options_.network_ignore_mask));
 
   rtc::scoped_refptr<PeerConnection> pc(
       new rtc::RefCountedObject<PeerConnection>(this));
 
   if (!pc->Initialize(configuration, std::move(allocator),
-                      std::move(dtls_identity_store), observer)) {
+                      std::move(cert_generator), observer)) {
     return nullptr;
   }
   return PeerConnectionProxy::Create(signaling_thread(), pc);
 }
 
 rtc::scoped_refptr<MediaStreamInterface>
 PeerConnectionFactory::CreateLocalMediaStream(const std::string& label) {
   RTC_DCHECK(signaling_thread_->IsCurrent());
   return MediaStreamProxy::Create(signaling_thread_,
                                   MediaStream::Create(label));
@@ skipping 39 matching lines @@
 }
 
 cricket::MediaEngineInterface* PeerConnectionFactory::CreateMediaEngine_w() {
   ASSERT(worker_thread_ == rtc::Thread::Current());
   return cricket::WebRtcMediaEngineFactory::Create(
       default_adm_.get(), video_encoder_factory_.get(),
       video_decoder_factory_.get());
 }
 
 }  // namespace webrtc