Injects FrameEncryptorInterface into RtpSender.

This change injects the FrameEncryptorInterface and the FrameDecryptorInterface
into the RtpSenderInterface and RtpReceiverInterface respectively. This is the
second stage of the injection. In a follow up CL non owning pointers to these
values will be passed down into the media channel.

This change also updates the corresponding mock files.

Bug: webrtc:9681
Change-Id: I964084fc270e10af9d1127979e713493e6fbba7d
Reviewed-on: https://webrtc-review.googlesource.com/96625
Commit-Queue: Benjamin Wright <benwright@webrtc.org>
Reviewed-by: Steve Anton <steveanton@webrtc.org>
Cr-Commit-Position: refs/heads/master@{#24489}

api/BUILD.gn

@@ -86,6 +86,7 @@ rtc_static_library("libjingle_peerconnection_api") {
     "rtpparameters.h",
     "rtpreceiverinterface.cc",
     "rtpreceiverinterface.h",
+    "rtpsenderinterface.cc",
     "rtpsenderinterface.h",
     "rtptransceiverinterface.cc",
     "rtptransceiverinterface.h",

api/crypto/framedecryptorinterface.h

@@ -29,7 +29,7 @@ namespace webrtc {
 // This interface is not ready for production use.
 class FrameDecryptorInterface : public rtc::RefCountInterface {
  public:
-  virtual ~FrameDecryptorInterface() {}
+  ~FrameDecryptorInterface() override {}
 
   // Attempts to decrypt the encrypted frame. You may assume the frame size will
   // be allocated to the size returned from GetOutputSize. You may assume that

api/crypto/frameencryptorinterface.h

@@ -27,7 +27,7 @@ namespace webrtc {
 // This interface is not ready for production use.
 class FrameEncryptorInterface : public rtc::RefCountInterface {
  public:
-  virtual ~FrameEncryptorInterface() {}
+  ~FrameEncryptorInterface() override {}
 
   // Attempts to encrypt the provided frame. You may assume the encrypted_frame
   // will match the size returned by GetOutputSize for a give frame. You may

api/rtpreceiverinterface.cc

@@ -45,4 +45,12 @@ std::vector<RtpSource> RtpReceiverInterface::GetSources() const {
   return {};
 }
 
+void RtpReceiverInterface::SetFrameDecryptor(
+    rtc::scoped_refptr<FrameDecryptorInterface> frame_decryptor) {}
+
+rtc::scoped_refptr<FrameDecryptorInterface>
+RtpReceiverInterface::GetFrameDecryptor() const {
+  return nullptr;
+}
+
 }  // namespace webrtc

api/rtpreceiverinterface.h

@@ -17,6 +17,7 @@
 #include <string>
 #include <vector>
 
+#include "api/crypto/framedecryptorinterface.h"
 #include "api/mediastreaminterface.h"
 #include "api/mediatypes.h"
 #include "api/proxy.h"
@@ -124,6 +125,17 @@ class RtpReceiverInterface : public rtc::RefCountInterface {
   // content::FakeRtpReceiver in Chromium.
   virtual std::vector<RtpSource> GetSources() const;
 
+  // Sets a user defined frame decryptor that will decrypt the entire frame
+  // before it is sent across the network. This will decrypt the entire frame
+  // using the user provided decryption mechanism regardless of whether SRTP is
+  // enabled or not.
+  virtual void SetFrameDecryptor(
+      rtc::scoped_refptr<FrameDecryptorInterface> frame_decryptor);
+
+  // Returns a pointer to the frame decryptor set previously by the
+  // user. This can be used to update the state of the object.
+  virtual rtc::scoped_refptr<FrameDecryptorInterface> GetFrameDecryptor() const;
+
  protected:
   ~RtpReceiverInterface() override = default;
 };
@@ -142,6 +154,11 @@ PROXY_CONSTMETHOD0(RtpParameters, GetParameters);
 PROXY_METHOD1(bool, SetParameters, const RtpParameters&)
 PROXY_METHOD1(void, SetObserver, RtpReceiverObserverInterface*);
 PROXY_CONSTMETHOD0(std::vector<RtpSource>, GetSources);
+PROXY_METHOD1(void,
+              SetFrameDecryptor,
+              rtc::scoped_refptr<FrameDecryptorInterface>);
+PROXY_CONSTMETHOD0(rtc::scoped_refptr<FrameDecryptorInterface>,
+                   GetFrameDecryptor);
 END_PROXY_MAP()
 
 }  // namespace webrtc

api/rtpsenderinterface.cc

@@ -0,0 +1,23 @@
+/*
+ *  Copyright 2018 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.
+ */
+
+#include "api/rtpsenderinterface.h"
+
+namespace webrtc {
+
+void RtpSenderInterface::SetFrameEncryptor(
+    rtc::scoped_refptr<FrameEncryptorInterface> frame_encryptor) {}
+
+rtc::scoped_refptr<FrameEncryptorInterface>
+RtpSenderInterface::GetFrameEncryptor() const {
+  return nullptr;
+}
+
+}  // namespace webrtc

api/rtpsenderinterface.h

@@ -17,6 +17,7 @@
 #include <string>
 #include <vector>
 
+#include "api/crypto/frameencryptorinterface.h"
 #include "api/dtmfsenderinterface.h"
 #include "api/mediastreaminterface.h"
 #include "api/mediatypes.h"
@@ -63,6 +64,17 @@ class RtpSenderInterface : public rtc::RefCountInterface {
   // Returns null for a video sender.
   virtual rtc::scoped_refptr<DtmfSenderInterface> GetDtmfSender() const = 0;
 
+  // Sets a user defined frame encryptor that will encrypt the entire frame
+  // before it is sent across the network. This will encrypt the entire frame
+  // using the user provided encryption mechanism regardless of whether SRTP is
+  // enabled or not.
+  virtual void SetFrameEncryptor(
+      rtc::scoped_refptr<FrameEncryptorInterface> frame_encryptor);
+
+  // Returns a pointer to the frame encryptor set previously by the
+  // user. This can be used to update the state of the object.
+  virtual rtc::scoped_refptr<FrameEncryptorInterface> GetFrameEncryptor() const;
+
  protected:
   ~RtpSenderInterface() override = default;
 };
@@ -81,6 +93,11 @@ PROXY_CONSTMETHOD0(std::vector<std::string>, stream_ids)
 PROXY_METHOD0(RtpParameters, GetParameters);
 PROXY_METHOD1(RTCError, SetParameters, const RtpParameters&)
 PROXY_CONSTMETHOD0(rtc::scoped_refptr<DtmfSenderInterface>, GetDtmfSender);
+PROXY_METHOD1(void,
+              SetFrameEncryptor,
+              rtc::scoped_refptr<FrameEncryptorInterface>);
+PROXY_CONSTMETHOD0(rtc::scoped_refptr<FrameEncryptorInterface>,
+                   GetFrameEncryptor);
 END_PROXY_MAP()
 
 }  // namespace webrtc

pc/rtpreceiver.cc

@@ -138,6 +138,16 @@ bool AudioRtpReceiver::SetParameters(const RtpParameters& parameters) {
   });
 }
 
+void AudioRtpReceiver::SetFrameDecryptor(
+    rtc::scoped_refptr<FrameDecryptorInterface> frame_decryptor) {
+  frame_decryptor_ = std::move(frame_decryptor);
+}
+
+rtc::scoped_refptr<FrameDecryptorInterface>
+AudioRtpReceiver::GetFrameDecryptor() const {
+  return frame_decryptor_;
+}
+
 void AudioRtpReceiver::Stop() {
   // TODO(deadbeef): Need to do more here to fully stop receiving packets.
   if (stopped_) {
@@ -308,6 +318,16 @@ bool VideoRtpReceiver::SetParameters(const RtpParameters& parameters) {
   });
 }
 
+void VideoRtpReceiver::SetFrameDecryptor(
+    rtc::scoped_refptr<FrameDecryptorInterface> frame_decryptor) {
+  frame_decryptor_ = std::move(frame_decryptor);
+}
+
+rtc::scoped_refptr<FrameDecryptorInterface>
+VideoRtpReceiver::GetFrameDecryptor() const {
+  return frame_decryptor_;
+}
+
 void VideoRtpReceiver::Stop() {
   // TODO(deadbeef): Need to do more here to fully stop receiving packets.
   if (stopped_) {

pc/rtpreceiver.h

@@ -115,6 +115,12 @@ class AudioRtpReceiver : public ObserverInterface,
   RtpParameters GetParameters() const override;
   bool SetParameters(const RtpParameters& parameters) override;
 
+  void SetFrameDecryptor(
+      rtc::scoped_refptr<FrameDecryptorInterface> frame_decryptor) override;
+
+  rtc::scoped_refptr<FrameDecryptorInterface> GetFrameDecryptor()
+      const override;
+
   // RtpReceiverInternal implementation.
   void Stop() override;
   void SetupMediaChannel(uint32_t ssrc) override;
@@ -155,6 +161,7 @@ class AudioRtpReceiver : public ObserverInterface,
   RtpReceiverObserverInterface* observer_ = nullptr;
   bool received_first_packet_ = false;
   int attachment_id_ = 0;
+  rtc::scoped_refptr<FrameDecryptorInterface> frame_decryptor_;
 };
 
 class VideoRtpReceiver : public rtc::RefCountedObject<RtpReceiverInternal> {
@@ -196,6 +203,12 @@ class VideoRtpReceiver : public rtc::RefCountedObject<RtpReceiverInternal> {
   RtpParameters GetParameters() const override;
   bool SetParameters(const RtpParameters& parameters) override;
 
+  void SetFrameDecryptor(
+      rtc::scoped_refptr<FrameDecryptorInterface> frame_decryptor) override;
+
+  rtc::scoped_refptr<FrameDecryptorInterface> GetFrameDecryptor()
+      const override;
+
   // RtpReceiverInternal implementation.
   void Stop() override;
   void SetupMediaChannel(uint32_t ssrc) override;
@@ -250,6 +263,7 @@ class VideoRtpReceiver : public rtc::RefCountedObject<RtpReceiverInternal> {
   RtpReceiverObserverInterface* observer_ = nullptr;
   bool received_first_packet_ = false;
   int attachment_id_ = 0;
+  rtc::scoped_refptr<FrameDecryptorInterface> frame_decryptor_;
 };
 
 }  // namespace webrtc

pc/rtpsender.cc

@@ -10,6 +10,7 @@
 
 #include "pc/rtpsender.h"
 
+#include <utility>
 #include <vector>
 
 #include "api/mediastreaminterface.h"
@@ -273,6 +274,16 @@ rtc::scoped_refptr<DtmfSenderInterface> AudioRtpSender::GetDtmfSender() const {
   return dtmf_sender_proxy_;
 }
 
+void AudioRtpSender::SetFrameEncryptor(
+    rtc::scoped_refptr<FrameEncryptorInterface> frame_encryptor) {
+  frame_encryptor_ = std::move(frame_encryptor);
+}
+
+rtc::scoped_refptr<FrameEncryptorInterface> AudioRtpSender::GetFrameEncryptor()
+    const {
+  return frame_encryptor_;
+}
+
 void AudioRtpSender::SetSsrc(uint32_t ssrc) {
   TRACE_EVENT0("webrtc", "AudioRtpSender::SetSsrc");
   if (stopped_ || ssrc == ssrc_) {
@@ -469,6 +480,16 @@ rtc::scoped_refptr<DtmfSenderInterface> VideoRtpSender::GetDtmfSender() const {
   return nullptr;
 }
 
+void VideoRtpSender::SetFrameEncryptor(
+    rtc::scoped_refptr<FrameEncryptorInterface> frame_encryptor) {
+  frame_encryptor_ = std::move(frame_encryptor);
+}
+
+rtc::scoped_refptr<FrameEncryptorInterface> VideoRtpSender::GetFrameEncryptor()
+    const {
+  return frame_encryptor_;
+}
+
 void VideoRtpSender::SetSsrc(uint32_t ssrc) {
   TRACE_EVENT0("webrtc", "VideoRtpSender::SetSsrc");
   if (stopped_ || ssrc == ssrc_) {

pc/rtpsender.h

@@ -127,6 +127,12 @@ class AudioRtpSender : public DtmfProviderInterface,
 
   rtc::scoped_refptr<DtmfSenderInterface> GetDtmfSender() const override;
 
+  void SetFrameEncryptor(
+      rtc::scoped_refptr<FrameEncryptorInterface> frame_encryptor) override;
+
+  rtc::scoped_refptr<FrameEncryptorInterface> GetFrameEncryptor()
+      const override;
+
   // RtpSenderInternal implementation.
   void SetSsrc(uint32_t ssrc) override;
 
@@ -175,6 +181,7 @@ class AudioRtpSender : public DtmfProviderInterface,
   // cricket::AudioSource.
   std::unique_ptr<LocalAudioSinkAdapter> sink_adapter_;
   int attachment_id_ = 0;
+  rtc::scoped_refptr<FrameEncryptorInterface> frame_encryptor_;
 };
 
 class VideoRtpSender : public ObserverInterface,
@@ -210,6 +217,12 @@ class VideoRtpSender : public ObserverInterface,
 
   rtc::scoped_refptr<DtmfSenderInterface> GetDtmfSender() const override;
 
+  void SetFrameEncryptor(
+      rtc::scoped_refptr<FrameEncryptorInterface> frame_encryptor) override;
+
+  rtc::scoped_refptr<FrameEncryptorInterface> GetFrameEncryptor()
+      const override;
+
   // RtpSenderInternal implementation.
   void SetSsrc(uint32_t ssrc) override;
 
@@ -248,6 +261,7 @@ class VideoRtpSender : public ObserverInterface,
       VideoTrackInterface::ContentHint::kNone;
   bool stopped_ = false;
   int attachment_id_ = 0;
+  rtc::scoped_refptr<FrameEncryptorInterface> frame_encryptor_;
 };
 
 }  // namespace webrtc

pc/test/mock_rtpreceiverinternal.h

@@ -34,6 +34,10 @@ class MockRtpReceiverInternal : public RtpReceiverInternal {
   MOCK_METHOD1(SetParameters, bool(const RtpParameters&));
   MOCK_METHOD1(SetObserver, void(RtpReceiverObserverInterface*));
   MOCK_CONST_METHOD0(GetSources, std::vector<RtpSource>());
+  MOCK_METHOD1(SetFrameDecryptor,
+               void(rtc::scoped_refptr<FrameDecryptorInterface>));
+  MOCK_CONST_METHOD0(GetFrameDecryptor,
+                     rtc::scoped_refptr<FrameDecryptorInterface>());
 
   // RtpReceiverInternal methods.
   MOCK_METHOD0(Stop, void());

pc/test/mock_rtpsenderinternal.h

@@ -32,6 +32,10 @@ class MockRtpSenderInternal : public RtpSenderInternal {
   MOCK_METHOD0(GetParameters, RtpParameters());
   MOCK_METHOD1(SetParameters, RTCError(const RtpParameters&));
   MOCK_CONST_METHOD0(GetDtmfSender, rtc::scoped_refptr<DtmfSenderInterface>());
+  MOCK_METHOD1(SetFrameEncryptor,
+               void(rtc::scoped_refptr<FrameEncryptorInterface>));
+  MOCK_CONST_METHOD0(GetFrameEncryptor,
+                     rtc::scoped_refptr<FrameEncryptorInterface>());
 
   // RtpSenderInternal methods.
   MOCK_METHOD1(SetVoiceMediaChannel, void(cricket::VoiceMediaChannel*));