DtlsIdentityStoreInterface added.

talk/app/webrtc/peerconnectioninterface.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 54 matching lines @@
 // 7. Once a candidate have been found PeerConnection will call the observer
 // function OnIceCandidate. Send these candidates to the remote peer.
 
 #ifndef TALK_APP_WEBRTC_PEERCONNECTIONINTERFACE_H_
 #define TALK_APP_WEBRTC_PEERCONNECTIONINTERFACE_H_
 
 #include <string>
 #include <vector>
 
 #include "talk/app/webrtc/datachannelinterface.h"
+#include "talk/app/webrtc/dtlsidentitystore.h"
 #include "talk/app/webrtc/dtmfsenderinterface.h"
 #include "talk/app/webrtc/jsep.h"
 #include "talk/app/webrtc/mediastreaminterface.h"
 #include "talk/app/webrtc/statstypes.h"
 #include "talk/app/webrtc/umametrics.h"
 #include "webrtc/base/fileutils.h"
 #include "webrtc/base/network.h"
 #include "webrtc/base/sslstreamadapter.h"
 #include "webrtc/base/socketaddress.h"
 
 namespace rtc {
 class SSLIdentity;
 class Thread;
 }
 
 namespace cricket {
 class PortAllocator;
 class WebRtcVideoDecoderFactory;
 class WebRtcVideoEncoderFactory;
 }
 
 namespace webrtc {
 class AudioDeviceModule;
+class DTLSIdentityRequestObserver;

[hbos, 2015/08/05 11:41:15]

Oops, unnecessary, will remove.

 class MediaConstraintsInterface;
 
 // MediaStream container interface.
 class StreamCollectionInterface : public rtc::RefCountInterface {
  public:
   // TODO(ronghuawu): Update the function names to c++ style, e.g. find -> Find.
   virtual size_t count() = 0;
   virtual MediaStreamInterface* at(size_t index) = 0;
   virtual MediaStreamInterface* find(const std::string& label) = 0;
   virtual MediaStreamTrackInterface* FindAudioTrack(
@@ skipping 351 matching lines @@
   // After this method is called, the port allocator should consider loopback
   // network interfaces as well.
   virtual void SetNetworkIgnoreMask(int network_ignore_mask) {
   }
 
  protected:
   PortAllocatorFactoryInterface() {}
   ~PortAllocatorFactoryInterface() {}
 };
 
-// Used to receive callbacks of DTLS identity requests.
-class DTLSIdentityRequestObserver : public rtc::RefCountInterface {
- public:
-  virtual void OnFailure(int error) = 0;
-  // TODO(jiayl): Unify the OnSuccess method once Chrome code is updated.
-  virtual void OnSuccess(const std::string& der_cert,
-                         const std::string& der_private_key) = 0;
-  // |identity| is a scoped_ptr because rtc::SSLIdentity is not copyable and the
-  // client has to get the ownership of the object to make use of it.
-  virtual void OnSuccessWithIdentityObj(
-      rtc::scoped_ptr<rtc::SSLIdentity> identity) = 0;
-
- protected:
-  virtual ~DTLSIdentityRequestObserver() {}
-};
-
 class DTLSIdentityServiceInterface {
  public:
   // Asynchronously request a DTLS identity, including a self-signed certificate
   // and the private key used to sign the certificate, from the identity store
   // for the given identity name.
   // DTLSIdentityRequestObserver::OnSuccess will be called with the identity if
   // the request succeeded; DTLSIdentityRequestObserver::OnFailure will be
   // called with an error code if the request failed.
   //
   // Only one request can be made at a time. If a second request is called
@@ skipping 46 matching lines @@
     int network_ignore_mask;
 
     // Sets the maximum supported protocol version. The highest version
     // supported by both ends will be used for the connection, i.e. if one
     // party supports DTLS 1.0 and the other DTLS 1.2, DTLS 1.0 will be used.
     rtc::SSLProtocolVersion ssl_max_version;
   };
 
   virtual void SetOptions(const Options& options) = 0;
 
+  // TODO(hbos): Temporary CreatePeerConnection function while we transition
+  // from DTLSIdentityServiceInterface to DtlsIdentityStoreInterface.
+  rtc::scoped_refptr<PeerConnectionInterface>
+      CreatePeerConnection(
+          const PeerConnectionInterface::RTCConfiguration& configuration,
+          const MediaConstraintsInterface* constraints,
+          PortAllocatorFactoryInterface* allocator_factory,
+          DTLSIdentityServiceInterface* dtls_identity_service,
+          rtc::scoped_ptr<DtlsIdentityStoreInterface> dtls_identity_store,
+          PeerConnectionObserver* observer) {
+    return CreatePeerConnection(configuration, constraints, allocator_factory,
+                                dtls_identity_service, observer);
+  }
+
   // This method takes the ownership of |dtls_identity_service|.
   virtual rtc::scoped_refptr<PeerConnectionInterface>
       CreatePeerConnection(
           const PeerConnectionInterface::RTCConfiguration& configuration,
           const MediaConstraintsInterface* constraints,
           PortAllocatorFactoryInterface* allocator_factory,
           DTLSIdentityServiceInterface* dtls_identity_service,
           PeerConnectionObserver* observer) = 0;
 
   // TODO(mallinath) : Remove below versions after clients are updated
@@ skipping 66 matching lines @@
 CreatePeerConnectionFactory(
     rtc::Thread* worker_thread,
     rtc::Thread* signaling_thread,
     AudioDeviceModule* default_adm,
     cricket::WebRtcVideoEncoderFactory* encoder_factory,
     cricket::WebRtcVideoDecoderFactory* decoder_factory);
 
 }  // namespace webrtc
 
 #endif  // TALK_APP_WEBRTC_PEERCONNECTIONINTERFACE_H_