Added DtlsCertificate, a ref counted object owning an SSLIdentity

talk/app/webrtc/peerconnection.cc

 /*
  * libjingle
  * Copyright 2012 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 333 matching lines @@
   if (stream_handler_container_)
     stream_handler_container_->TearDown();
 }
 
 bool PeerConnection::Initialize(
     const PeerConnectionInterface::RTCConfiguration& configuration,
     const MediaConstraintsInterface* constraints,
     PortAllocatorFactoryInterface* allocator_factory,
     rtc::scoped_ptr<DtlsIdentityStoreInterface> dtls_identity_store,
     PeerConnectionObserver* observer) {
+  if (!InitializeInternal(configuration, constraints, allocator_factory,
+                          observer)) {
+    return false;
+  }
+
+  // Initialize the WebRtcSession with our optional |dtls_identity_store|.
+  // It creates transport channels etc.
+  if (!session_->Initialize(factory_->options(), constraints,

[tommi (sloooow) - chröme, 2015/08/18 14:49:35]

return session_->Initialize(...);

+                            dtls_identity_store.Pass(), configuration)) {
+    return false;

[tommi (sloooow) - chröme, 2015/08/18 14:49:35]

if we hit this, do we have to undo some of the work already done by
InitializeInternal?

+  }
+  return true;
+}
+
+bool PeerConnection::Initialize(
+    const PeerConnectionInterface::RTCConfiguration& configuration,
+    const MediaConstraintsInterface* constraints,
+    PortAllocatorFactoryInterface* allocator_factory,
+    const rtc::scoped_refptr<DtlsCertificate>& certificate,
+    PeerConnectionObserver* observer) {
+  DCHECK(certificate.get());
+  if (!InitializeInternal(configuration, constraints, allocator_factory,
+                          observer)) {
+    return false;
+  }
+
+  // Initialize the WebRtcSession with our |certificate|.
+  // It creates transport channels etc.
+  if (!session_->Initialize(factory_->options(), constraints,

[tommi (sloooow) - chröme, 2015/08/18 14:49:35]

nit:

return session_->Initialize(...);

+                            certificate, configuration)) {
+    return false;
+  }
+  return true;
+}
+
+bool PeerConnection::InitializeInternal(
+    const PeerConnectionInterface::RTCConfiguration& configuration,
+    const MediaConstraintsInterface* constraints,
+    PortAllocatorFactoryInterface* allocator_factory,
+    PeerConnectionObserver* observer) {
   ASSERT(observer != NULL);
   if (!observer)
     return false;
   observer_ = observer;
 
   std::vector<PortAllocatorFactoryInterface::StunConfiguration> stun_config;
   std::vector<PortAllocatorFactoryInterface::TurnConfiguration> turn_config;
   if (!ParseIceServers(configuration.servers, &stun_config, &turn_config)) {
     return false;
   }
@@ skipping 28 matching lines @@
   port_allocator_->set_step_delay(cricket::kMinimumStepDelay);
 
   mediastream_signaling_.reset(new MediaStreamSignaling(
       factory_->signaling_thread(), this, factory_->channel_manager()));
 
   session_.reset(new WebRtcSession(factory_->channel_manager(),
                                    factory_->signaling_thread(),
                                    factory_->worker_thread(),
                                    port_allocator_.get(),
                                    mediastream_signaling_.get()));
-  stream_handler_container_.reset(new MediaStreamHandlerContainer(
-      session_.get(), session_.get()));
-  stats_.reset(new StatsCollector(session_.get()));
-
-  // Initialize the WebRtcSession. It creates transport channels etc.
-  if (!session_->Initialize(factory_->options(), constraints,
-                            dtls_identity_store.Pass(), configuration))
-    return false;
-
   // Register PeerConnection as receiver of local ice candidates.
   // All the callbacks will be posted to the application from PeerConnection.
   session_->RegisterIceObserver(this);
   session_->SignalState.connect(this, &PeerConnection::OnSessionStateChange);
+
+  stream_handler_container_.reset(new MediaStreamHandlerContainer(
+      session_.get(), session_.get()));
+  stats_.reset(new StatsCollector(session_.get()));
   return true;
 }
 
 rtc::scoped_refptr<StreamCollectionInterface>
 PeerConnection::local_streams() {
   return mediastream_signaling_->local_streams();
 }
 
 rtc::scoped_refptr<StreamCollectionInterface>
 PeerConnection::remote_streams() {
@@ skipping 480 matching lines @@
     if (ice_gathering_state_ != kIceGatheringComplete) {
       ice_gathering_state_ = kIceGatheringComplete;
       observer_->OnIceGatheringChange(ice_gathering_state_);
     }
   }
   observer_->OnSignalingChange(signaling_state_);
   observer_->OnStateChange(PeerConnectionObserver::kSignalingState);
 }
 
 }  // namespace webrtc