Added DtlsCertificate, a ref counted object owning an SSLIdentity

webrtc/p2p/base/session.h

 /*
  *  Copyright 2004 The WebRTC Project Authors. All rights reserved.
  *
  *  Use of this source code is governed by a BSD-style license
  *  that can be found in the LICENSE file in the root of the source
  *  tree. An additional intellectual property rights grant can be found
  *  in the file PATENTS.  All contributing project authors may
  *  be found in the AUTHORS file in the root of the source tree.
  */
 
@@ skipping 82 matching lines @@
   // Start the connection process for any channels, creating impls if needed.
   void ConnectChannels();
   // Hook up impls to the proxy channels. Doesn't change connect state.
   void CompleteNegotiation();
 
   // Mux this proxy onto the specified proxy's transport.
   bool SetupMux(TransportProxy* proxy);
 
   // Simple functions that thunk down to the same functions on Transport.
   void SetIceRole(IceRole role);
-  void SetIdentity(rtc::SSLIdentity* identity);
+  void SetCertificate(
+      const rtc::scoped_refptr<webrtc::DtlsCertificate>& certificate);
   bool SetLocalTransportDescription(const TransportDescription& description,
                                     ContentAction action,
                                     std::string* error_desc);
   bool SetRemoteTransportDescription(const TransportDescription& description,
                                      ContentAction action,
                                      std::string* error_desc);
   void OnSignalingReady();
   bool OnRemoteCandidates(const Candidates& candidates, std::string* error);
 
   // Called when a transport signals that it has new candidates.
@@ skipping 196 matching lines @@
   virtual TransportChannel* GetChannel(const std::string& content_name,
                                        int component);
 
   // Destroys the channel with the given names.
   // This will usually be called from the worker thread, but that
   // shouldn't be an issue since the main thread will be blocked in
   // Send when doing so.
   virtual void DestroyChannel(const std::string& content_name,
                               int component);
 
-  rtc::SSLIdentity* identity() { return identity_; }
+  const rtc::scoped_refptr<webrtc::DtlsCertificate>& certificate() {
+    return certificate_;
+  }
 
   // Set the ice connection receiving timeout.
   void SetIceConnectionReceivingTimeout(int timeout_ms);
 
  protected:
-  // Specifies the identity to use in this session.
-  bool SetIdentity(rtc::SSLIdentity* identity);
+  // Specifies the certificate to use in this session.
+  bool SetCertificate(
+      const rtc::scoped_refptr<webrtc::DtlsCertificate>& certificate);
 
   bool SetSslMaxProtocolVersion(rtc::SSLProtocolVersion version);
 
   bool PushdownTransportDescription(ContentSource source,
                                     ContentAction action,
                                     std::string* error_desc);
   void set_initiator(bool initiator) { initiator_ = initiator; }
 
   const TransportMap& transport_proxies() const { return transports_; }
   // Get a TransportProxy by content_name or transport. NULL if not found.
@@ skipping 102 matching lines @@
                                       const std::string& content_name,
                                       TransportDescription* info);
 
   rtc::Thread* const signaling_thread_;
   rtc::Thread* const worker_thread_;
   PortAllocator* const port_allocator_;
   const std::string sid_;
   const std::string content_type_;
   const std::string transport_type_;
   bool initiator_;
-  rtc::SSLIdentity* identity_;
+  rtc::scoped_refptr<webrtc::DtlsCertificate> certificate_;
   rtc::SSLProtocolVersion ssl_max_version_;
   rtc::scoped_ptr<const SessionDescription> local_description_;
   rtc::scoped_ptr<SessionDescription> remote_description_;
   uint64 ice_tiebreaker_;
   // This flag will be set to true after the first role switch. This flag
   // will enable us to stop any role switch during the call.
   bool role_switch_;
   TransportMap transports_;
 
   // Timeout value in milliseconds for which no ICE connection receives
   // any packets.
   int ice_receiving_timeout_;
 };
 
 }  // namespace cricket
 
 #endif  // WEBRTC_P2P_BASE_SESSION_H_