Added DtlsCertificate, a ref counted object owning an SSLIdentity

talk/app/webrtc/webrtcsession.h

 /*
  * 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 13 matching lines @@
  * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
  * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
 #ifndef TALK_APP_WEBRTC_WEBRTCSESSION_H_
 #define TALK_APP_WEBRTC_WEBRTCSESSION_H_
 
 #include <string>
 
 #include "talk/app/webrtc/datachannel.h"
+#include "talk/app/webrtc/dtlscertificate.h"
 #include "talk/app/webrtc/dtmfsender.h"
 #include "talk/app/webrtc/mediastreamprovider.h"
 #include "talk/app/webrtc/peerconnectioninterface.h"
 #include "talk/app/webrtc/statstypes.h"
 #include "talk/media/base/mediachannel.h"
 #include "webrtc/p2p/base/session.h"
 #include "talk/session/media/mediasession.h"
 #include "webrtc/base/sigslot.h"
 #include "webrtc/base/thread.h"
 
@@ skipping 71 matching lines @@
                       public DtmfProviderInterface,
                       public DataChannelProviderInterface {
  public:
   WebRtcSession(cricket::ChannelManager* channel_manager,
                 rtc::Thread* signaling_thread,
                 rtc::Thread* worker_thread,
                 cricket::PortAllocator* port_allocator,
                 MediaStreamSignaling* mediastream_signaling);
   virtual ~WebRtcSession();
 
+  // This method takes the ownership of |dtls_identity_service|.
   bool Initialize(
       const PeerConnectionFactoryInterface::Options& options,
       const MediaConstraintsInterface* constraints,
       DTLSIdentityServiceInterface* dtls_identity_service,
       const PeerConnectionInterface::RTCConfiguration& rtc_configuration);
+  bool Initialize(
+      const PeerConnectionFactoryInterface::Options& options,
+      const MediaConstraintsInterface* constraints,
+      rtc::scoped_refptr<webrtc::DtlsCertificate> certificate,
+      const PeerConnectionInterface::RTCConfiguration& rtc_configuration);
   // Deletes the voice, video and data channel and changes the session state
   // to STATE_RECEIVEDTERMINATE.
   void Terminate();
 
   void RegisterIceObserver(IceObserver* observer) {
     ice_observer_ = observer;
   }
 
   virtual cricket::VoiceChannel* voice_channel() {
     return voice_channel_.get();
@@ skipping 98 matching lines @@
   rtc::scoped_refptr<DataChannel> CreateDataChannel(
       const std::string& label,
       const InternalDataChannelInit* config) override;
 
   cricket::DataChannelType data_channel_type() const;
 
   bool IceRestartPending() const;
 
   void ResetIceRestartLatch();
 
-  // Called when an SSLIdentity is generated or retrieved by
+  // Called when a DtlsCertificate is generated or retrieved by
   // WebRTCSessionDescriptionFactory. Should happen before setLocalDescription.
-  void OnIdentityReady(rtc::SSLIdentity* identity);
+  void OnCertificateReady(rtc::scoped_refptr<DtlsCertificate> certificate);
   void OnDtlsSetupFailure(cricket::BaseChannel*, bool rtcp);
 
   // For unit test.
-  bool waiting_for_identity() const;
+  bool waiting_for_certificate() const;
+  rtc::scoped_refptr<DtlsCertificate> get_certificate() const;
 
   void set_metrics_observer(
       webrtc::MetricsObserverInterface* metrics_observer) {
     metrics_observer_ = metrics_observer;
   }
 
  private:
   // Indicates the type of SessionDescription in a call to SetLocalDescription
   // and SetRemoteDescription.
   enum Action {
     kOffer,
     kPrAnswer,
     kAnswer,
   };
 
+  bool InitializeCommon(
+      const PeerConnectionFactoryInterface::Options& options,
+      const MediaConstraintsInterface* constraints,
+      const PeerConnectionInterface::RTCConfiguration& rtc_configuration);
+  void InitializeFactoryAfterConstruction(
+      const PeerConnectionFactoryInterface::Options& options);
+
   // Invokes ConnectChannels() on transport proxies, which initiates ice
   // candidates allocation.
   bool StartCandidatesAllocation();
   bool UpdateSessionState(Action action, cricket::ContentSource source,
                           std::string* err_desc);
   static Action GetAction(const std::string& type);
   // Push the media parts of the local or remote session description
   // down to all of the channels.
   bool PushdownMediaDescription(cricket::ContentAction action,
                                 cricket::ContentSource source,
@@ skipping 105 matching lines @@
   bool dtls_enabled_;
   // Specifies which kind of data channel is allowed. This is controlled
   // by the chrome command-line flag and constraints:
   // 1. If chrome command-line switch 'enable-sctp-data-channels' is enabled,
   // constraint kEnableDtlsSrtp is true, and constaint kEnableRtpDataChannels is
   // not set or false, SCTP is allowed (DCT_SCTP);
   // 2. If constraint kEnableRtpDataChannels is true, RTP is allowed (DCT_RTP);
   // 3. If both 1&2 are false, data channel is not allowed (DCT_NONE).
   cricket::DataChannelType data_channel_type_;
   rtc::scoped_ptr<IceRestartAnswerLatch> ice_restart_latch_;
+  rtc::scoped_refptr<DtlsCertificate> certificate_;
 
   rtc::scoped_ptr<WebRtcSessionDescriptionFactory>
       webrtc_session_desc_factory_;
 
   sigslot::signal0<> SignalVoiceChannelDestroyed;
   sigslot::signal0<> SignalVideoChannelDestroyed;
   sigslot::signal0<> SignalDataChannelDestroyed;
 
   // Member variables for caching global options.
   cricket::AudioOptions audio_options_;
   cricket::VideoOptions video_options_;
   MetricsObserverInterface* metrics_observer_;
 
   // Declares the bundle policy for the WebRTCSession.
   PeerConnectionInterface::BundlePolicy bundle_policy_;
 
   // Declares the RTCP mux policy for the WebRTCSession.
   PeerConnectionInterface::RtcpMuxPolicy rtcp_mux_policy_;
 
   DISALLOW_COPY_AND_ASSIGN(WebRtcSession);
 };
 }  // namespace webrtc
 
 #endif  // TALK_APP_WEBRTC_WEBRTCSESSION_H_