Added DtlsCertificate, a ref counted object owning an SSLIdentity

talk/app/webrtc/peerconnectionfactory.cc

 /*
  * libjingle
  * Copyright 2004--2011 Google Inc.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions are met:
  *
  *  1. Redistributions of source code must retain the above copyright notice,
  *     this list of conditions and the following disclaimer.
  *  2. Redistributions in binary form must reproduce the above copyright notice,
@@ skipping 189 matching lines @@
   return channel_manager_->StartAecDump(file);
 }
 
 rtc::scoped_refptr<PeerConnectionInterface>
 PeerConnectionFactory::CreatePeerConnection(
     const PeerConnectionInterface::RTCConfiguration& configuration,
     const MediaConstraintsInterface* constraints,
     PortAllocatorFactoryInterface* allocator_factory,
     DTLSIdentityServiceInterface* dtls_identity_service,
     PeerConnectionObserver* observer) {
-  DCHECK(signaling_thread_->IsCurrent());
-  DCHECK(allocator_factory || default_allocator_factory_);
+  PortAllocatorFactoryInterface* chosen_allocator_factory =
+      CreatePeerConnectionCommon(allocator_factory);
 
   if (!dtls_identity_service) {
     dtls_identity_service = new DtlsIdentityService(dtls_identity_store_.get());
   }
 
+  rtc::scoped_refptr<PeerConnection> pc(
+      new rtc::RefCountedObject<PeerConnection>(this));
+  // Note: |pc| takes ownership of |dtls_identity_service|.
+  if (!pc->Initialize(
+      configuration,
+      constraints,
+      chosen_allocator_factory,
+      dtls_identity_service,
+      observer)) {
+    return nullptr;
+  }
+  return PeerConnectionProxy::Create(signaling_thread(), pc);
+}
+
+rtc::scoped_refptr<PeerConnectionInterface>
+PeerConnectionFactory::CreatePeerConnection(
+    const PeerConnectionInterface::RTCConfiguration& configuration,
+    const MediaConstraintsInterface* constraints,
+    PortAllocatorFactoryInterface* allocator_factory,
+    rtc::scoped_refptr<DtlsCertificate> certificate,
+    PeerConnectionObserver* observer) {
   PortAllocatorFactoryInterface* chosen_allocator_factory =
-      allocator_factory ? allocator_factory : default_allocator_factory_.get();
-  chosen_allocator_factory->SetNetworkIgnoreMask(options_.network_ignore_mask);
+      CreatePeerConnectionCommon(allocator_factory);
 
   rtc::scoped_refptr<PeerConnection> pc(
       new rtc::RefCountedObject<PeerConnection>(this));
   if (!pc->Initialize(
       configuration,
       constraints,
       chosen_allocator_factory,
-      dtls_identity_service,
+      certificate,
       observer)) {
-    return NULL;
+    return nullptr;
   }
   return PeerConnectionProxy::Create(signaling_thread(), pc);
 }
 
+PortAllocatorFactoryInterface*
+PeerConnectionFactory::CreatePeerConnectionCommon(
+    PortAllocatorFactoryInterface* allocator_factory) {
+  DCHECK(signaling_thread_->IsCurrent());
+  DCHECK(allocator_factory || default_allocator_factory_);
+
+  PortAllocatorFactoryInterface* chosen_allocator_factory =
+      allocator_factory ? allocator_factory : default_allocator_factory_.get();
+  chosen_allocator_factory->SetNetworkIgnoreMask(options_.network_ignore_mask);
+
+  return chosen_allocator_factory;
+}
+
 rtc::scoped_refptr<MediaStreamInterface>
 PeerConnectionFactory::CreateLocalMediaStream(const std::string& label) {
   DCHECK(signaling_thread_->IsCurrent());
   return MediaStreamProxy::Create(signaling_thread_,
                                   MediaStream::Create(label));
 }
 
 rtc::scoped_refptr<VideoTrackInterface>
 PeerConnectionFactory::CreateVideoTrack(
     const std::string& id,
@@ skipping 30 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