Add support for GCM cipher suites from RFC 7714.

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 156 matching lines @@
 
   // 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_; }
 
+  bool SetEnableGcmCryptoSuites(bool enable);
+
  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) {
     local_content_direction_ = direction;
@@ skipping 97 matching lines @@
   bool SetRtcpMux_w(bool enable,
                     ContentAction action,
                     ContentSource src,
                     std::string* error_desc);
 
   // From MessageHandler
   void OnMessage(rtc::Message* pmsg) override;
 
   // Handled in derived classes
   // Get the SRTP crypto suites to use for RTP media
-  virtual void GetSrtpCryptoSuites(std::vector<int>* crypto_suites) const = 0;
+  virtual void GetSrtpCryptoSuites(std::vector<int>* crypto_suites,
+      const MediaSessionOptions& options) const = 0;
   virtual void OnConnectionMonitorUpdate(ConnectionMonitor* monitor,
       const std::vector<ConnectionInfo>& infos) = 0;
 
   // Helper function for invoking bool-returning methods on the worker thread.
   template <class FunctorT>
   bool InvokeOnWorker(const FunctorT& functor) {
     return worker_thread_->Invoke<bool>(functor);
   }
 
  private:
@@ skipping 17 matching lines @@
   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_;
   bool has_received_packet_;
   bool dtls_keyed_;
   bool secure_required_;
+  bool enable_gcm_crypto_suites_;
   int rtp_abs_sendtime_extn_id_;
 };
 
 // VoiceChannel is a specialization that adds support for early media, DTMF,
 // and input/output level monitoring.
 class VoiceChannel : public BaseChannel {
  public:
   VoiceChannel(rtc::Thread* thread,
                MediaEngineInterface* media_engine,
                VoiceMediaChannel* channel,
@@ skipping 66 matching lines @@
                                  std::string* error_desc);
   virtual bool SetRemoteContent_w(const MediaContentDescription* content,
                                   ContentAction action,
                                   std::string* error_desc);
   void HandleEarlyMediaTimeout();
   bool InsertDtmf_w(uint32_t ssrc, int event, int duration);
   bool SetOutputVolume_w(uint32_t ssrc, double volume);
   bool GetStats_w(VoiceMediaInfo* stats);
 
   virtual void OnMessage(rtc::Message* pmsg);
-  virtual void GetSrtpCryptoSuites(std::vector<int>* crypto_suites) const;
+  void GetSrtpCryptoSuites(std::vector<int>* crypto_suites,
+      const MediaSessionOptions& options) const override;
   virtual void OnConnectionMonitorUpdate(
       ConnectionMonitor* monitor, const std::vector<ConnectionInfo>& infos);
   virtual void OnMediaMonitorUpdate(
       VoiceMediaChannel* media_channel, const VoiceMediaInfo& info);
   void OnAudioMonitorUpdate(AudioMonitor* monitor, const AudioInfo& info);
 
   static const int kEarlyMediaTimeout = 1000;
   MediaEngineInterface* media_engine_;
   bool received_media_;
   rtc::scoped_ptr<VoiceMediaMonitor> media_monitor_;
@@ skipping 69 matching lines @@
   bool ApplyViewRequest_w(const ViewRequest& request);
 
   bool AddScreencast_w(uint32_t ssrc, VideoCapturer* capturer);
   bool RemoveScreencast_w(uint32_t ssrc);
   void OnScreencastWindowEvent_s(uint32_t ssrc, rtc::WindowEvent we);
   bool IsScreencasting_w() const;
   void GetScreencastDetails_w(ScreencastDetailsData* d) const;
   bool GetStats_w(VideoMediaInfo* stats);
 
   virtual void OnMessage(rtc::Message* pmsg);
-  virtual void GetSrtpCryptoSuites(std::vector<int>* crypto_suites) const;
+  void GetSrtpCryptoSuites(std::vector<int>* crypto_suites,
+      const MediaSessionOptions& options) const override;
   virtual void OnConnectionMonitorUpdate(
       ConnectionMonitor* monitor, const std::vector<ConnectionInfo>& infos);
   virtual void OnMediaMonitorUpdate(
       VideoMediaChannel* media_channel, const VideoMediaInfo& info);
   virtual void OnScreencastWindowEvent(uint32_t ssrc, rtc::WindowEvent event);
   virtual void OnStateChange(VideoCapturer* capturer, CaptureState ev);
   bool GetLocalSsrc(const VideoCapturer* capturer, uint32_t* ssrc);
 
   VideoRenderer* renderer_;
   ScreencastMap screencast_capturers_;
@@ skipping 96 matching lines @@
   virtual bool SetLocalContent_w(const MediaContentDescription* content,
                                  ContentAction action,
                                  std::string* error_desc);
   virtual bool SetRemoteContent_w(const MediaContentDescription* content,
                                   ContentAction action,
                                   std::string* error_desc);
   virtual void ChangeState();
   virtual bool WantsPacket(bool rtcp, rtc::Buffer* packet);
 
   virtual void OnMessage(rtc::Message* pmsg);
-  virtual void GetSrtpCryptoSuites(std::vector<int>* crypto_suites) const;
+  void GetSrtpCryptoSuites(std::vector<int>* crypto_suites,
+      const MediaSessionOptions& options) const override;
   virtual void OnConnectionMonitorUpdate(
       ConnectionMonitor* monitor, const std::vector<ConnectionInfo>& infos);
   virtual void OnMediaMonitorUpdate(
       DataMediaChannel* media_channel, const DataMediaInfo& info);
   virtual bool ShouldSetupDtlsSrtp() const;
   void OnDataReceived(
       const ReceiveDataParams& params, const char* data, size_t len);
   void OnDataChannelError(uint32_t ssrc, DataMediaChannel::Error error);
   void OnDataChannelReadyToSend(bool writable);
   void OnStreamClosedRemotely(uint32_t sid);
 
   rtc::scoped_ptr<DataMediaMonitor> media_monitor_;
   // TODO(pthatcher): Make a separate SctpDataChannel and
   // RtpDataChannel instead of using this.
   DataChannelType data_channel_type_;
   bool ready_to_send_data_;
 
   // Last DataSendParameters sent down to the media_channel() via
   // 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_