Revert of Completed the functionalities of SrtpTransport.

pc/srtpfilter.h

Index: pc/srtpfilter.h
diff --git a/pc/srtpfilter.h b/pc/srtpfilter.h
index ffdf637ae9cf175c501933059d5a9784ab420557..7b1127e655e90289d40d96076432e54c15d9b590 100644
--- a/pc/srtpfilter.h
+++ b/pc/srtpfilter.h
@@ -17,11 +17,9 @@
 #include <string>
 #include <vector>
 
-#include "api/optional.h"
 #include "media/base/cryptoparams.h"
 #include "p2p/base/sessiondescription.h"
 #include "rtc_base/basictypes.h"
-#include "rtc_base/buffer.h"
 #include "rtc_base/constructormagic.h"
 #include "rtc_base/criticalsection.h"
 #include "rtc_base/sslstreamadapter.h"
@@ -33,10 +31,16 @@ struct srtp_ctx_t_;
 
 namespace cricket {
 
+class SrtpSession;
+
 void ShutdownSrtp();
 
-// A helper class used to negotiate SDES crypto params.
-// TODO(zhihuang): Find a better name for this class, like "SdesNegotiator".
+// Class to transform SRTP to/from RTP.
+// Initialize by calling SetSend with the local security params, then
+// call
+// SetRecv once the remote security params are received. At that point
+// Protect/UnprotectRt(c)p can be called to encrypt/decrypt data.
+// TODO: Figure out concurrency policy for SrtpFilter.
 class SrtpFilter {
  public:
   enum Mode {
@@ -73,13 +77,65 @@ class SrtpFilter {
   bool SetAnswer(const std::vector<CryptoParams>& answer_params,
                  ContentSource source);
 
-  bool ResetParams();
-
-  rtc::Optional<int> send_cipher_suite() { return send_cipher_suite_; }
-  rtc::Optional<int> recv_cipher_suite() { return recv_cipher_suite_; }
+  // Set the header extension ids that should be encrypted for the given
+  // source.
+  void SetEncryptedHeaderExtensionIds(ContentSource source,
+                                      const std::vector<int>& extension_ids);
+  // Just set up both sets of keys directly.
+  // Used with DTLS-SRTP.
+  bool SetRtpParams(int send_cs,
+                    const uint8_t* send_key,
+                    int send_key_len,
+                    int recv_cs,
+                    const uint8_t* recv_key,
+                    int recv_key_len);
+  bool UpdateRtpParams(int send_cs,
+                       const uint8_t* send_key,
+                       int send_key_len,
+                       int recv_cs,
+                       const uint8_t* recv_key,
+                       int recv_key_len);
+  bool SetRtcpParams(int send_cs,
+                     const uint8_t* send_key,
+                     int send_key_len,
+                     int recv_cs,
+                     const uint8_t* recv_key,
+                     int recv_key_len);
+  // Encrypts/signs an individual RTP/RTCP packet, in-place.
+  // If an HMAC is used, this will increase the packet size.
+  bool ProtectRtp(void* data, int in_len, int max_len, int* out_len);
+  // Overloaded version, outputs packet index.
+  bool ProtectRtp(void* data,
+                  int in_len,
+                  int max_len,
+                  int* out_len,
+                  int64_t* index);
+  bool ProtectRtcp(void* data, int in_len, int max_len, int* out_len);
+  // Decrypts/verifies an invidiual RTP/RTCP packet.
+  // If an HMAC is used, this will decrease the packet size.
+  bool UnprotectRtp(void* data, int in_len, int* out_len);
+  bool UnprotectRtcp(void* data, int in_len, int* out_len);
+  // Returns rtp auth params from srtp context.
+  bool GetRtpAuthParams(uint8_t** key, int* key_len, int* tag_len);
+  // Returns srtp overhead for rtp packets.
+  bool GetSrtpOverhead(int* srtp_overhead) const;
+  // If external auth is enabled, SRTP will write a dummy auth tag that
+  // then
+  // later must get replaced before the packet is sent out. Only
+  // supported for
+  // non-GCM cipher suites and can be checked through
+  // "IsExternalAuthActive"
+  // if it is actually used. This method is only valid before the RTP
+  // params
+  // have been set.
+  void EnableExternalAuth();
+  bool IsExternalAuthEnabled() const;
+  // A SRTP filter supports external creation of the auth tag if a non-GCM
+  // cipher is used. This method is only valid after the RTP params have
+  // been set.
+  bool IsExternalAuthActive() const;
 
-  const rtc::Buffer& send_key() { return send_key_; }
-  const rtc::Buffer& recv_key() { return recv_key_; }
+  bool ResetParams();
 
  protected:
   bool ExpectOffer(ContentSource source);
@@ -93,18 +149,17 @@ class SrtpFilter {
                    ContentSource source,
                    bool final);
 
+  void CreateSrtpSessions();
   bool NegotiateParams(const std::vector<CryptoParams>& answer_params,
                        CryptoParams* selected_params);
 
- private:
-  bool ApplySendParams(const CryptoParams& send_params);
-
-  bool ApplyRecvParams(const CryptoParams& recv_params);
-
+  bool ApplyParams(const CryptoParams& send_params,
+                   const CryptoParams& recv_params);
   static bool ParseKeyParams(const std::string& params,
                              uint8_t* key,
                              size_t len);
 
+ private:
   enum State {
     ST_INIT,           // SRTP filter unused.
     ST_SENTOFFER,      // Offer with SRTP parameters sent.
@@ -129,13 +184,16 @@ class SrtpFilter {
     ST_RECEIVEDPRANSWER
   };
   State state_ = ST_INIT;
+  bool external_auth_enabled_ = false;
   std::vector<CryptoParams> offer_params_;
+  std::unique_ptr<SrtpSession> send_session_;
+  std::unique_ptr<SrtpSession> recv_session_;
+  std::unique_ptr<SrtpSession> send_rtcp_session_;
+  std::unique_ptr<SrtpSession> recv_rtcp_session_;
   CryptoParams applied_send_params_;
   CryptoParams applied_recv_params_;
-  rtc::Optional<int> send_cipher_suite_;
-  rtc::Optional<int> recv_cipher_suite_;
-  rtc::Buffer send_key_;
-  rtc::Buffer recv_key_;
+  std::vector<int> send_encrypted_header_extension_ids_;
+  std::vector<int> recv_encrypted_header_extension_ids_;
 };
 
 }  // namespace cricket