RTCCertificates added to RTCConfiguration, used by WebRtcSession/-DescriptionFactory

talk/app/webrtc/webrtcsessiondescriptionfactory.h

 /*
  * libjingle
  * Copyright 2013 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 15 matching lines @@
  */
 
 #ifndef TALK_APP_WEBRTC_WEBRTCSESSIONDESCRIPTIONFACTORY_H_
 #define TALK_APP_WEBRTC_WEBRTCSESSIONDESCRIPTIONFACTORY_H_
 
 #include "talk/app/webrtc/dtlsidentitystore.h"
 #include "talk/app/webrtc/peerconnectioninterface.h"
 #include "talk/session/media/mediasession.h"
 #include "webrtc/p2p/base/transportdescriptionfactory.h"
 #include "webrtc/base/messagehandler.h"
+#include "webrtc/base/rtccertificate.h"
 
 namespace cricket {
 class ChannelManager;
 class TransportDescriptionFactory;
 }  // namespace cricket
 
 namespace webrtc {
 class CreateSessionDescriptionObserver;
 class MediaConstraintsInterface;
 class MediaStreamSignaling;
@@ skipping 34 matching lines @@
 };
 
 // This class is used to create offer/answer session description with regards to
 // the async DTLS identity generation for WebRtcSession.
 // It queues the create offer/answer request until the DTLS identity
 // request has completed, i.e. when OnIdentityRequestFailed or OnIdentityReady
 // is called.
 class WebRtcSessionDescriptionFactory : public rtc::MessageHandler,
                                         public sigslot::has_slots<> {
  public:
+  // Construct with DTLS disabled.
+  WebRtcSessionDescriptionFactory(
+      rtc::Thread* signaling_thread,
+      cricket::ChannelManager* channel_manager,
+      MediaStreamSignaling* mediastream_signaling,
+      WebRtcSession* session,
+      const std::string& session_id,
+      cricket::DataChannelType dct);
+
+  // Construct with DTLS enabled using the specified |dtls_identity_store| to
+  // generate a certificate.
   WebRtcSessionDescriptionFactory(

[tommi, 2015/08/24 11:26:33]

will this ctor eventually be deleted?

[hbos, 2015/08/24 12:01:34]

Remember that if no certificates are provided we still have to generate them for
the caller, with the same functionality as before the latest RFC.

|dtls_identity_store| is required for as long as we want to allow projects using
WebRTC to be able to supply own identity generation code in this event. Such as
Chrome having its own RSA generation code today. It would be nice to remove it
but that will likely have performance implications.

In fact, for as long as this holds true, our GenerateCertificate function (not
yet added) will need to (optionally) take a |dtls_identity_store| argument as
well.

When ECDSA is the default and RSA is "almost abandoned" we might not care about
this and always use the webrtc implementation of the store, in which case they
can be removed (along with the possibility of Chrome generating keys before
WebRTC comes into the picture).

       rtc::Thread* signaling_thread,
       cricket::ChannelManager* channel_manager,
       MediaStreamSignaling* mediastream_signaling,
       rtc::scoped_ptr<DtlsIdentityStoreInterface> dtls_identity_store,
-      // TODO(jiayl): remove the dependency on session once bug 2264 is fixed.
       WebRtcSession* session,
       const std::string& session_id,
-      cricket::DataChannelType dct,
-      bool dtls_enabled);
+      cricket::DataChannelType dct);
+
+  // Construct with DTLS enabled using the specified (already generated)
+  // |certificate|.
+  WebRtcSessionDescriptionFactory(
+      rtc::Thread* signaling_thread,
+      cricket::ChannelManager* channel_manager,
+      MediaStreamSignaling* mediastream_signaling,
+      rtc::scoped_refptr<rtc::RTCCertificate> certificate,

[tommi, 2015/08/24 11:26:33]

const &

[hbos, 2015/08/24 12:01:34]

Done.

+      WebRtcSession* session,
+      const std::string& session_id,
+      cricket::DataChannelType dct);
   virtual ~WebRtcSessionDescriptionFactory();
 
   static void CopyCandidatesFromSessionDescription(
     const SessionDescriptionInterface* source_desc,
     SessionDescriptionInterface* dest_desc);
 
   void CreateOffer(
       CreateSessionDescriptionObserver* observer,
       const PeerConnectionInterface::RTCOfferAnswerOptions& options);
   void CreateAnswer(
       CreateSessionDescriptionObserver* observer,
       const MediaConstraintsInterface* constraints);
 
   void SetSdesPolicy(cricket::SecurePolicy secure_policy);
   cricket::SecurePolicy SdesPolicy() const;
 
   sigslot::signal1<rtc::SSLIdentity*> SignalIdentityReady;
 
   // For testing.
-  bool waiting_for_identity() const {
-    return identity_request_state_ == IDENTITY_WAITING;
+  bool waiting_for_certificate_for_testing() const {
+    return certificate_request_state_ == CERTIFICATE_WAITING;
   }
 
  private:
-  enum IdentityRequestState {
-    IDENTITY_NOT_NEEDED,
-    IDENTITY_WAITING,
-    IDENTITY_SUCCEEDED,
-    IDENTITY_FAILED,
+  enum CertificateRequestState {
+    CERTIFICATE_NOT_NEEDED,
+    CERTIFICATE_WAITING,
+    CERTIFICATE_SUCCEEDED,
+    CERTIFICATE_FAILED,
   };
 
+  WebRtcSessionDescriptionFactory(
+      rtc::Thread* signaling_thread,
+      cricket::ChannelManager* channel_manager,
+      MediaStreamSignaling* mediastream_signaling,
+      rtc::scoped_ptr<DtlsIdentityStoreInterface> dtls_identity_store,
+      const rtc::scoped_refptr<WebRtcIdentityRequestObserver>&
+          identity_request_observer,
+      WebRtcSession* session,
+      const std::string& session_id,
+      cricket::DataChannelType dct,
+      bool dtls_enabled);
+
   // MessageHandler implementation.
   virtual void OnMessage(rtc::Message* msg);
 
   void InternalCreateOffer(CreateSessionDescriptionRequest request);
   void InternalCreateAnswer(CreateSessionDescriptionRequest request);
   // Posts failure notifications for all pending session description requests.
   void FailPendingRequests(const std::string& reason);
   void PostCreateSessionDescriptionFailed(
       CreateSessionDescriptionObserver* observer,
       const std::string& error);
   void PostCreateSessionDescriptionSucceeded(
       CreateSessionDescriptionObserver* observer,
       SessionDescriptionInterface* description);
 
   void OnIdentityRequestFailed(int error);
   void SetIdentity(rtc::SSLIdentity* identity);
 
   std::queue<CreateSessionDescriptionRequest>
       create_session_description_requests_;
   rtc::Thread* const signaling_thread_;
   MediaStreamSignaling* const mediastream_signaling_;
   cricket::TransportDescriptionFactory transport_desc_factory_;
   cricket::MediaSessionDescriptionFactory session_desc_factory_;
   uint64 session_version_;
-  rtc::scoped_ptr<DtlsIdentityStoreInterface> dtls_identity_store_;
-  rtc::scoped_refptr<WebRtcIdentityRequestObserver> identity_request_observer_;
+  const rtc::scoped_ptr<DtlsIdentityStoreInterface> dtls_identity_store_;
+  const rtc::scoped_refptr<WebRtcIdentityRequestObserver>
+      identity_request_observer_;
+  // TODO(jiayl): remove the dependency on session once bug 2264 is fixed.
   WebRtcSession* const session_;
   const std::string session_id_;
   const cricket::DataChannelType data_channel_type_;
-  IdentityRequestState identity_request_state_;
+  CertificateRequestState certificate_request_state_;
 
   DISALLOW_COPY_AND_ASSIGN(WebRtcSessionDescriptionFactory);
 };
 }  // namespace webrtc
 
 #endif  // TALK_APP_WEBRTC_WEBRTCSESSIONDESCRIPTIONFACTORY_H_