Replaces SSLIdentity* with scoped_refptr<RTCCertificate> in cricket::Transport layer.

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.
  */
 
 #ifndef WEBRTC_P2P_BASE_SESSION_H_
 #define WEBRTC_P2P_BASE_SESSION_H_
 
 #include <list>
 #include <map>
 #include <string>
 #include <vector>
 
 #include "webrtc/p2p/base/candidate.h"
 #include "webrtc/p2p/base/port.h"
 #include "webrtc/p2p/base/transport.h"
 #include "webrtc/base/refcount.h"
+#include "webrtc/base/rtccertificate.h"
 #include "webrtc/base/scoped_ptr.h"
 #include "webrtc/base/scoped_ref_ptr.h"
 #include "webrtc/base/socketaddress.h"
 
 namespace cricket {
 
 class BaseSession;
 class P2PTransportChannel;
 class Transport;
 class TransportChannel;
@@ skipping 60 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<rtc::RTCCertificate>& 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 194 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_; }
-
   // Set the ice connection receiving timeout.
   void SetIceConnectionReceivingTimeout(int timeout_ms);
 
+  // For testing.
+  const rtc::scoped_refptr<rtc::RTCCertificate>&
+  certificate_for_testing() const {
+    return certificate_;
+  }
+
  protected:
   // Specifies the identity to use in this session.
-  bool SetIdentity(rtc::SSLIdentity* identity);
+  bool SetCertificate(
+      const rtc::scoped_refptr<rtc::RTCCertificate>& 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 101 matching lines @@
   static bool GetTransportDescription(const SessionDescription* description,
                                       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_;
   bool initiator_;
-  rtc::SSLIdentity* identity_;
+  rtc::scoped_refptr<rtc::RTCCertificate> 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_