Allow remote fingerprint update during a call

talk/session/media/channel.h

 /*
  * libjingle
  * Copyright 2004 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 82 matching lines @@
   const std::string& transport_name() const { return transport_name_; }
   TransportChannel* transport_channel() const {
     return transport_channel_;
   }
   TransportChannel* rtcp_transport_channel() const {
     return rtcp_transport_channel_;
   }
   bool enabled() const { return enabled_; }
 
   // This function returns true if we are using SRTP.
-  bool secure() const { return srtp_filter_.IsActive(); }
+  bool secure() const { return srtp_filter_->IsActive(); }
   // The following function returns true if we are using
   // DTLS-based keying. If you turned off SRTP later, however
   // you could have secure() == false and dtls_secure() == true.
   bool secure_dtls() const { return dtls_keyed_; }
   // This function returns true if we require secure channel for call setup.
   bool secure_required() const { return secure_required_; }
 
   bool writable() const { return writable_; }
 
   // Activate RTCP mux, regardless of the state so far.  Once
@@ skipping 46 matching lines @@
   // Used for latency measurements.
   sigslot::signal1<BaseChannel*> SignalFirstPacketReceived;
 
   // Made public for easier testing.
   void SetReadyToSend(bool rtcp, bool ready);
 
   // Only public for unit tests.  Otherwise, consider protected.
   int SetOption(SocketType type, rtc::Socket::Option o, int val)
       override;
 
-  SrtpFilter* srtp_filter() { return &srtp_filter_; }
+  SrtpFilter* srtp_filter() { return srtp_filter_.get(); }
 
  protected:
   virtual MediaChannel* media_channel() const { return media_channel_; }
   // Sets the |transport_channel_| (and |rtcp_transport_channel_|, if |rtcp_| is
   // true). Gets the transport channels from |transport_controller_|.
   bool SetTransport_w(const std::string& transport_name);
   void set_transport_channel(TransportChannel* transport);
   void set_rtcp_transport_channel(TransportChannel* transport);
   bool was_ever_writable() const { return was_ever_writable_; }
   void set_local_content_direction(MediaContentDirection direction) {
@@ skipping 25 matching lines @@
 
   // From TransportChannel
   void OnWritableState(TransportChannel* channel);
   virtual void OnChannelRead(TransportChannel* channel,
                              const char* data,
                              size_t len,
                              const rtc::PacketTime& packet_time,
                              int flags);
   void OnReadyToSend(TransportChannel* channel);
 
+  void OnDtlsSrtpSetup(TransportChannel* channel);
+
   bool PacketIsRtcp(const TransportChannel* channel, const char* data,
                     size_t len);
   bool SendPacket(bool rtcp,
                   rtc::Buffer* packet,
                   const rtc::PacketOptions& options);
   virtual bool WantsPacket(bool rtcp, rtc::Buffer* packet);
   void HandlePacket(bool rtcp, rtc::Buffer* packet,
                     const rtc::PacketTime& packet_time);
 
   void EnableMedia_w();
   void DisableMedia_w();
   void UpdateWritableState_w();
   void ChannelWritable_w();
   void ChannelNotWritable_w();
   bool AddRecvStream_w(const StreamParams& sp);
   bool RemoveRecvStream_w(uint32_t ssrc);
   bool AddSendStream_w(const StreamParams& sp);
   bool RemoveSendStream_w(uint32_t ssrc);
   virtual bool ShouldSetupDtlsSrtp() const;
+  bool IsUsingDtlsSrtp() const;
   // Do the DTLS key expansion and impose it on the SRTP/SRTCP filters.
   // |rtcp_channel| indicates whether to set up the RTP or RTCP filter.
   bool SetupDtlsSrtp(bool rtcp_channel);
   // Set the DTLS-SRTP cipher policy on this channel as appropriate.
   bool SetDtlsSrtpCiphers(TransportChannel *tc, bool rtcp);
 
   virtual void ChangeState() = 0;
 
   // Gets the content info appropriate to the channel (audio or video).
   virtual const ContentInfo* GetFirstContent(
@@ skipping 56 matching lines @@
   std::vector<StreamParams> local_streams_;
   std::vector<StreamParams> remote_streams_;
 
   const std::string content_name_;
   std::string transport_name_;
   bool rtcp_transport_enabled_;
   TransportChannel* transport_channel_;
   std::vector<std::pair<rtc::Socket::Option, int> > socket_options_;
   TransportChannel* rtcp_transport_channel_;
   std::vector<std::pair<rtc::Socket::Option, int> > rtcp_socket_options_;
-  SrtpFilter srtp_filter_;
+  rtc::scoped_ptr<SrtpFilter> srtp_filter_;
   RtcpMuxFilter rtcp_mux_filter_;
   BundleFilter bundle_filter_;
   rtc::scoped_ptr<ConnectionMonitor> connection_monitor_;
   bool enabled_;
   bool writable_;
   bool rtp_ready_to_send_;
   bool rtcp_ready_to_send_;
   bool was_ever_writable_;
   MediaContentDirection local_content_direction_;
   MediaContentDirection remote_content_direction_;
@@ skipping 314 matching lines @@
   // SetSendParameters.
   DataSendParameters last_send_params_;
   // Last DataRecvParameters sent down to the media_channel() via
   // SetRecvParameters.
   DataRecvParameters last_recv_params_;
 };
 
 }  // namespace cricket
 
 #endif  // TALK_SESSION_MEDIA_CHANNEL_H_