Added DtlsCertificate, a ref counted object owning an SSLIdentity

webrtc/p2p/base/fakesession.h

 /*
  *  Copyright 2009 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 31 matching lines @@
                              public rtc::MessageHandler {
  public:
   explicit FakeTransportChannel(Transport* transport,
                                 const std::string& content_name,
                                 int component)
       : TransportChannelImpl(content_name, component),
         transport_(transport),
         dest_(NULL),
         state_(STATE_INIT),
         async_(false),
-        identity_(NULL),
+        certificate_(nullptr),
         do_dtls_(false),
         role_(ICEROLE_UNKNOWN),
         tiebreaker_(0),
         ice_proto_(ICEPROTO_HYBRID),
         remote_ice_mode_(ICEMODE_FULL),
         dtls_fingerprint_("", NULL, 0),
         ssl_role_(rtc::SSL_CLIENT),
         connection_count_(0) {
   }
   ~FakeTransportChannel() {
@@ skipping 83 matching lines @@
 
   void SetWritable(bool writable) {
     set_writable(writable);
   }
 
   void SetDestination(FakeTransportChannel* dest) {
     if (state_ == STATE_CONNECTING && dest) {
       // This simulates the delivery of candidates.
       dest_ = dest;
       dest_->dest_ = this;
-      if (identity_ && dest_->identity_) {
+      if (certificate_ && dest_->certificate_) {
         do_dtls_ = true;
         dest_->do_dtls_ = true;
         NegotiateSrtpCiphers();
       }
       state_ = STATE_CONNECTED;
       dest_->state_ = STATE_CONNECTED;
       set_writable(true);
       dest_->set_writable(true);
     } else if (state_ == STATE_CONNECTED && !dest) {
       // Simulates loss of connectivity, by asymmetrically forgetting dest_.
@@ skipping 50 matching lines @@
   }
 
   virtual void OnMessage(rtc::Message* msg) {
     PacketMessageData* data = static_cast<PacketMessageData*>(
         msg->pdata);
     dest_->SignalReadPacket(dest_, data->packet.data<char>(),
                             data->packet.size(), rtc::CreatePacketTime(0), 0);
     delete data;
   }
 
-  bool SetLocalIdentity(rtc::SSLIdentity* identity) {
-    identity_ = identity;
+  bool SetLocalCertificate(
+      const rtc::scoped_refptr<webrtc::DtlsCertificate>& certificate) override {
+    certificate_ = certificate;
     return true;
   }
 
 
   void SetRemoteCertificate(rtc::FakeSSLCertificate* cert) {
     remote_cert_ = cert;
   }
 
   virtual bool IsDtlsActive() const {
     return do_dtls_;
   }
 
   virtual bool SetSrtpCiphers(const std::vector<std::string>& ciphers) {
     srtp_ciphers_ = ciphers;
     return true;
   }
 
   virtual bool GetSrtpCipher(std::string* cipher) {
     if (!chosen_srtp_cipher_.empty()) {
       *cipher = chosen_srtp_cipher_;
       return true;
     }
     return false;
   }
 
   virtual bool GetSslCipher(std::string* cipher) {
     return false;
   }
 
-  virtual bool GetLocalIdentity(rtc::SSLIdentity** identity) const {
-    if (!identity_)
+  bool GetLocalCertificate(
+      rtc::scoped_refptr<webrtc::DtlsCertificate>* certificate) const override {
+    if (!certificate_.get())
       return false;
 
-    *identity = identity_->GetReference();
+    *certificate = certificate_;
     return true;
   }
 
-  virtual bool GetRemoteCertificate(rtc::SSLCertificate** cert) const {
+  bool GetRemoteCertificate(rtc::SSLCertificate** cert) const override {
     if (!remote_cert_)
       return false;
 
     *cert = remote_cert_->GetReference();
     return true;
   }
 
   virtual bool ExportKeyingMaterial(const std::string& label,
                                     const uint8* context,
                                     size_t context_len,
@@ skipping 29 matching lines @@
     infos->push_back(info);
     return true;
   }
 
  private:
   enum State { STATE_INIT, STATE_CONNECTING, STATE_CONNECTED };
   Transport* transport_;
   FakeTransportChannel* dest_;
   State state_;
   bool async_;
-  rtc::SSLIdentity* identity_;
+  rtc::scoped_refptr<webrtc::DtlsCertificate> certificate_;
   rtc::FakeSSLCertificate* remote_cert_;
   bool do_dtls_;
   std::vector<std::string> srtp_ciphers_;
   std::string chosen_srtp_cipher_;
   IceRole role_;
   uint64 tiebreaker_;
   IceProtocolType ice_proto_;
   std::string ice_ufrag_;
   std::string ice_pwd_;
   std::string remote_ice_ufrag_;
   std::string remote_ice_pwd_;
   IceMode remote_ice_mode_;
   rtc::SSLFingerprint dtls_fingerprint_;
   rtc::SSLRole ssl_role_;
   size_t connection_count_;
 };
 
 // Fake transport class, which can be passed to anything that needs a Transport.
 // Can be informed of another FakeTransport via SetDestination (low-tech way
 // of doing candidates)
 class FakeTransport : public Transport {
  public:
   typedef std::map<int, FakeTransportChannel*> ChannelMap;
   FakeTransport(rtc::Thread* signaling_thread,
                 rtc::Thread* worker_thread,
                 const std::string& content_name,
-                PortAllocator* alllocator = NULL)
+                PortAllocator* alllocator = nullptr)
       : Transport(signaling_thread, worker_thread,
-                  content_name, "test_type", NULL),
-      dest_(NULL),
+                  content_name, "test_type", nullptr),
+      dest_(nullptr),
       async_(false),
-      identity_(NULL) {
+      certificate_(nullptr) {
   }
   ~FakeTransport() {
     DestroyAllChannels();
   }
 
   const ChannelMap& channels() const { return channels_; }
 
   void SetAsync(bool async) { async_ = async; }
   void SetDestination(FakeTransport* dest) {
     dest_ = dest;
     for (ChannelMap::iterator it = channels_.begin(); it != channels_.end();
          ++it) {
-      it->second->SetLocalIdentity(identity_);
+      it->second->SetLocalCertificate(certificate_);
       SetChannelDestination(it->first, it->second);
     }
   }
 
   void SetWritable(bool writable) {
     for (ChannelMap::iterator it = channels_.begin(); it != channels_.end();
          ++it) {
       it->second->SetWritable(writable);
     }
   }
 
-  void set_identity(rtc::SSLIdentity* identity) {
-    identity_ = identity;
+  void set_certificate(
+      const rtc::scoped_refptr<webrtc::DtlsCertificate>& certificate) {
+    certificate_ = certificate;
   }
 
   using Transport::local_description;
   using Transport::remote_description;
 
  protected:
   virtual TransportChannelImpl* CreateTransportChannel(int component) {
     if (channels_.find(component) != channels_.end()) {
       return NULL;
     }
     FakeTransportChannel* channel =
         new FakeTransportChannel(this, content_name(), component);
     channel->SetAsync(async_);
     SetChannelDestination(component, channel);
     channels_[component] = channel;
     return channel;
   }
   virtual void DestroyTransportChannel(TransportChannelImpl* channel) {
     channels_.erase(channel->component());
     delete channel;
   }
-  virtual void SetIdentity_w(rtc::SSLIdentity* identity) {
-    identity_ = identity;
+  void SetCertificate_w(
+      const rtc::scoped_refptr<webrtc::DtlsCertificate>& certificate) override {
+    certificate_ = certificate;
   }
-  virtual bool GetIdentity_w(rtc::SSLIdentity** identity) {
-    if (!identity_)
+  bool GetCertificate_w(
+      rtc::scoped_refptr<webrtc::DtlsCertificate>* certificate) override {
+    if (!certificate_.get())
       return false;
 
-    *identity = identity_->GetReference();
+    *certificate = certificate_;
     return true;
   }
 
  private:
   FakeTransportChannel* GetFakeChannel(int component) {
     ChannelMap::iterator it = channels_.find(component);
     return (it != channels_.end()) ? it->second : NULL;
   }
   void SetChannelDestination(int component,
                              FakeTransportChannel* channel) {
     FakeTransportChannel* dest_channel = NULL;
     if (dest_) {
       dest_channel = dest_->GetFakeChannel(component);
       if (dest_channel) {
-        dest_channel->SetLocalIdentity(dest_->identity_);
+        dest_channel->SetLocalCertificate(dest_->certificate_);
       }
     }
     channel->SetDestination(dest_channel);
   }
 
   // Note, this is distinct from the Channel map owned by Transport.
   // This map just tracks the FakeTransportChannels created by this class.
   ChannelMap channels_;
   FakeTransport* dest_;
   bool async_;
-  rtc::SSLIdentity* identity_;
+  rtc::scoped_refptr<webrtc::DtlsCertificate> certificate_;
 };
 
 // Fake session class, which can be passed into a BaseChannel object for
 // test purposes. Can be connected to other FakeSessions via Connect().
 class FakeSession : public BaseSession {
  public:
   explicit FakeSession()
       : BaseSession(rtc::Thread::Current(),
                     rtc::Thread::Current(),
                     NULL, "", "", true),
@@ skipping 35 matching lines @@
       return NULL;
     }
     return BaseSession::CreateChannel(content_name, component);
   }
 
   void set_fail_channel_creation(bool fail_channel_creation) {
     fail_create_channel_ = fail_channel_creation;
   }
 
   // TODO: Hoist this into Session when we re-work the Session code.
-  void set_ssl_identity(rtc::SSLIdentity* identity) {
+  void set_ssl_certificate(
+      const rtc::scoped_refptr<webrtc::DtlsCertificate>& certificate) {
     for (TransportMap::const_iterator it = transport_proxies().begin();
         it != transport_proxies().end(); ++it) {
       // We know that we have a FakeTransport*
 
-      static_cast<FakeTransport*>(it->second->impl())->set_identity
-          (identity);
+      static_cast<FakeTransport*>(it->second->impl())->set_certificate
+          (certificate);
     }
   }
 
  protected:
   virtual Transport* CreateTransport(const std::string& content_name) {
     return new FakeTransport(signaling_thread(), worker_thread(), content_name);
   }
 
   void CompleteNegotiation() {
     for (TransportMap::const_iterator it = transport_proxies().begin();
         it != transport_proxies().end(); ++it) {
       it->second->CompleteNegotiation();
       it->second->ConnectChannels();
     }
   }
 
  private:
   bool fail_create_channel_;
 };
 
 }  // namespace cricket
 
 #endif  // WEBRTC_P2P_BASE_FAKESESSION_H_